/*
 *
 *    Copyright (c) 2022 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

// THIS FILE IS GENERATED BY ZAP

#pragma once

#include <cstdint>
#include <string>
#include <type_traits>

#include <app-common/zap-generated/cluster-objects.h>
#include <commands/clusters/ClusterCommand.h>
#include <commands/clusters/ComplexArgument.h>
#include <commands/clusters/ReportCommand.h>
#include <commands/clusters/WriteAttributeCommand.h>

/*----------------------------------------------------------------------------*\
| Cluster Name                                                        |   ID   |
|---------------------------------------------------------------------+--------|
| AccessControl                                                       | 0x001F |
| AccountLogin                                                        | 0x050E |
| AdministratorCommissioning                                          | 0x003C |
| ApplicationBasic                                                    | 0x050D |
| ApplicationLauncher                                                 | 0x050C |
| AudioOutput                                                         | 0x050B |
| BarrierControl                                                      | 0x0103 |
| Basic                                                               | 0x0028 |
| BinaryInputBasic                                                    | 0x000F |
| Binding                                                             | 0x001E |
| BooleanState                                                        | 0x0045 |
| BridgedActions                                                      | 0x0025 |
| BridgedDeviceBasic                                                  | 0x0039 |
| Channel                                                             | 0x0504 |
| ColorControl                                                        | 0x0300 |
| ContentLauncher                                                     | 0x050A |
| Descriptor                                                          | 0x001D |
| DiagnosticLogs                                                      | 0x0032 |
| DoorLock                                                            | 0x0101 |
| ElectricalMeasurement                                               | 0x0B04 |
| EthernetNetworkDiagnostics                                          | 0x0037 |
| FixedLabel                                                          | 0x0040 |
| FlowMeasurement                                                     | 0x0404 |
| GeneralCommissioning                                                | 0x0030 |
| GeneralDiagnostics                                                  | 0x0033 |
| GroupKeyManagement                                                  | 0x003F |
| Groups                                                              | 0x0004 |
| Identify                                                            | 0x0003 |
| IlluminanceMeasurement                                              | 0x0400 |
| KeypadInput                                                         | 0x0509 |
| LevelControl                                                        | 0x0008 |
| LocalizationConfiguration                                           | 0x002B |
| LowPower                                                            | 0x0508 |
| MediaInput                                                          | 0x0507 |
| MediaPlayback                                                       | 0x0506 |
| ModeSelect                                                          | 0x0050 |
| NetworkCommissioning                                                | 0x0031 |
| OtaSoftwareUpdateProvider                                           | 0x0029 |
| OtaSoftwareUpdateRequestor                                          | 0x002A |
| OccupancySensing                                                    | 0x0406 |
| OnOff                                                               | 0x0006 |
| OnOffSwitchConfiguration                                            | 0x0007 |
| OperationalCredentials                                              | 0x003E |
| PowerSource                                                         | 0x002F |
| PowerSourceConfiguration                                            | 0x002E |
| PressureMeasurement                                                 | 0x0403 |
| PumpConfigurationAndControl                                         | 0x0200 |
| RelativeHumidityMeasurement                                         | 0x0405 |
| Scenes                                                              | 0x0005 |
| SoftwareDiagnostics                                                 | 0x0034 |
| Switch                                                              | 0x003B |
| TargetNavigator                                                     | 0x0505 |
| TemperatureMeasurement                                              | 0x0402 |
| TestCluster                                                         | 0x050F |
| Thermostat                                                          | 0x0201 |
| ThermostatUserInterfaceConfiguration                                | 0x0204 |
| ThreadNetworkDiagnostics                                            | 0x0035 |
| TimeFormatLocalization                                              | 0x002C |
| UnitLocalization                                                    | 0x002D |
| UserLabel                                                           | 0x0041 |
| WakeOnLan                                                           | 0x0503 |
| WiFiNetworkDiagnostics                                              | 0x0036 |
| WindowCovering                                                      | 0x0102 |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster AccessControl                                               | 0x001F |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Acl                                                               | 0x0000 |
| * Extension                                                         | 0x0001 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * AccessControlEntryChanged                                         | 0x0000 |
| * AccessControlExtensionChanged                                     | 0x0001 |
\*----------------------------------------------------------------------------*/

class WriteAccessControlAcl : public WriteAttribute
{
public:
    WriteAccessControlAcl(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("Acl", credsIssuerConfig), mComplex(&mValue)
    {
        AddArgument("attr-name", "acl");
        AddArgument("attr-value", &mComplex);
        WriteAttribute::AddArguments();
    }

    ~WriteAccessControlAcl() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000001F, 0x00000000, mValue);
    }

private:
    chip::app::DataModel::List<const chip::app::Clusters::AccessControl::Structs::AccessControlEntry::Type> mValue;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::AccessControl::Structs::AccessControlEntry::Type>>
        mComplex;
};

class WriteAccessControlExtension : public WriteAttribute
{
public:
    WriteAccessControlExtension(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("Extension", credsIssuerConfig), mComplex(&mValue)
    {
        AddArgument("attr-name", "extension");
        AddArgument("attr-value", &mComplex);
        WriteAttribute::AddArguments();
    }

    ~WriteAccessControlExtension() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000001F, 0x00000001, mValue);
    }

private:
    chip::app::DataModel::List<const chip::app::Clusters::AccessControl::Structs::ExtensionEntry::Type> mValue;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::AccessControl::Structs::ExtensionEntry::Type>>
        mComplex;
};

/*----------------------------------------------------------------------------*\
| Cluster AccountLogin                                                | 0x050E |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * GetSetupPINRequest                                                |   0x00 |
| * LoginRequest                                                      |   0x02 |
| * LogoutRequest                                                     |   0x03 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command GetSetupPINRequest
 */
class AccountLoginGetSetupPINRequest : public ClusterCommand
{
public:
    AccountLoginGetSetupPINRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("get-setup-pinrequest", credsIssuerConfig)
    {
        AddArgument("TempAccountIdentifier", &mRequest.tempAccountIdentifier);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050E) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050E, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::AccountLogin::Commands::GetSetupPINRequest::Type mRequest;
};

/*
 * Command LoginRequest
 */
class AccountLoginLoginRequest : public ClusterCommand
{
public:
    AccountLoginLoginRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("login-request", credsIssuerConfig)
    {
        AddArgument("TempAccountIdentifier", &mRequest.tempAccountIdentifier);
        AddArgument("SetupPIN", &mRequest.setupPIN);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050E) command (0x00000002) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050E, 0x00000002, mRequest);
    }

private:
    chip::app::Clusters::AccountLogin::Commands::LoginRequest::Type mRequest;
};

/*
 * Command LogoutRequest
 */
class AccountLoginLogoutRequest : public ClusterCommand
{
public:
    AccountLoginLogoutRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("logout-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050E) command (0x00000003) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050E, 0x00000003, mRequest);
    }

private:
    chip::app::Clusters::AccountLogin::Commands::LogoutRequest::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster AdministratorCommissioning                                  | 0x003C |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * OpenBasicCommissioningWindow                                      |   0x01 |
| * OpenCommissioningWindow                                           |   0x00 |
| * RevokeCommissioning                                               |   0x02 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * WindowStatus                                                      | 0x0000 |
| * AdminFabricIndex                                                  | 0x0001 |
| * AdminVendorId                                                     | 0x0002 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command OpenBasicCommissioningWindow
 */
class AdministratorCommissioningOpenBasicCommissioningWindow : public ClusterCommand
{
public:
    AdministratorCommissioningOpenBasicCommissioningWindow(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("open-basic-commissioning-window", credsIssuerConfig)
    {
        AddArgument("CommissioningTimeout", 0, UINT16_MAX, &mRequest.commissioningTimeout);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000003C) command (0x00000001) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000003C, 0x00000001, mRequest);
    }

private:
    chip::app::Clusters::AdministratorCommissioning::Commands::OpenBasicCommissioningWindow::Type mRequest;
};

/*
 * Command OpenCommissioningWindow
 */
class AdministratorCommissioningOpenCommissioningWindow : public ClusterCommand
{
public:
    AdministratorCommissioningOpenCommissioningWindow(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("open-commissioning-window", credsIssuerConfig)
    {
        AddArgument("CommissioningTimeout", 0, UINT16_MAX, &mRequest.commissioningTimeout);
        AddArgument("PAKEVerifier", &mRequest.PAKEVerifier);
        AddArgument("Discriminator", 0, UINT16_MAX, &mRequest.discriminator);
        AddArgument("Iterations", 0, UINT32_MAX, &mRequest.iterations);
        AddArgument("Salt", &mRequest.salt);
        AddArgument("PasscodeID", 0, UINT16_MAX, &mRequest.passcodeID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000003C) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000003C, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::AdministratorCommissioning::Commands::OpenCommissioningWindow::Type mRequest;
};

/*
 * Command RevokeCommissioning
 */
class AdministratorCommissioningRevokeCommissioning : public ClusterCommand
{
public:
    AdministratorCommissioningRevokeCommissioning(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("revoke-commissioning", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000003C) command (0x00000002) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000003C, 0x00000002, mRequest);
    }

private:
    chip::app::Clusters::AdministratorCommissioning::Commands::RevokeCommissioning::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster ApplicationBasic                                            | 0x050D |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * VendorName                                                        | 0x0000 |
| * VendorId                                                          | 0x0001 |
| * ApplicationName                                                   | 0x0002 |
| * ProductId                                                         | 0x0003 |
| * ApplicationApp                                                    | 0x0004 |
| * ApplicationStatus                                                 | 0x0005 |
| * ApplicationVersion                                                | 0x0006 |
| * AllowedVendorList                                                 | 0x0007 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster ApplicationLauncher                                         | 0x050C |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * HideAppRequest                                                    |   0x02 |
| * LaunchAppRequest                                                  |   0x00 |
| * StopAppRequest                                                    |   0x01 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * ApplicationLauncherList                                           | 0x0000 |
| * ApplicationLauncherApp                                            | 0x0001 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command HideAppRequest
 */
class ApplicationLauncherHideAppRequest : public ClusterCommand
{
public:
    ApplicationLauncherHideAppRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("hide-app-request", credsIssuerConfig), mComplex_Application(&mRequest.application)
    {
        AddArgument("Application", &mComplex_Application);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050C) command (0x00000002) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050C, 0x00000002, mRequest);
    }

private:
    chip::app::Clusters::ApplicationLauncher::Commands::HideAppRequest::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::ApplicationLauncher::Structs::Application::Type> mComplex_Application;
};

/*
 * Command LaunchAppRequest
 */
class ApplicationLauncherLaunchAppRequest : public ClusterCommand
{
public:
    ApplicationLauncherLaunchAppRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("launch-app-request", credsIssuerConfig), mComplex_Application(&mRequest.application)
    {
        AddArgument("Application", &mComplex_Application);
        AddArgument("Data", &mRequest.data);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050C) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050C, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::ApplicationLauncher::Commands::LaunchAppRequest::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::ApplicationLauncher::Structs::Application::Type> mComplex_Application;
};

/*
 * Command StopAppRequest
 */
class ApplicationLauncherStopAppRequest : public ClusterCommand
{
public:
    ApplicationLauncherStopAppRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("stop-app-request", credsIssuerConfig), mComplex_Application(&mRequest.application)
    {
        AddArgument("Application", &mComplex_Application);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050C) command (0x00000001) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050C, 0x00000001, mRequest);
    }

private:
    chip::app::Clusters::ApplicationLauncher::Commands::StopAppRequest::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::ApplicationLauncher::Structs::Application::Type> mComplex_Application;
};

class WriteApplicationLauncherApplicationLauncherApp : public WriteAttribute
{
public:
    WriteApplicationLauncherApplicationLauncherApp(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("ApplicationLauncherApp", credsIssuerConfig), mComplex(&mValue)
    {
        AddArgument("attr-name", "application-launcher-app");
        AddArgument("attr-value", &mComplex);
        WriteAttribute::AddArguments();
    }

    ~WriteApplicationLauncherApplicationLauncherApp() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050C, 0x00000001, mValue);
    }

private:
    chip::app::DataModel::Nullable<chip::app::Clusters::ApplicationLauncher::Structs::ApplicationEP::Type> mValue;
    TypedComplexArgument<chip::app::DataModel::Nullable<chip::app::Clusters::ApplicationLauncher::Structs::ApplicationEP::Type>>
        mComplex;
};

/*----------------------------------------------------------------------------*\
| Cluster AudioOutput                                                 | 0x050B |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * RenameOutputRequest                                               |   0x01 |
| * SelectOutputRequest                                               |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * AudioOutputList                                                   | 0x0000 |
| * CurrentAudioOutput                                                | 0x0001 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command RenameOutputRequest
 */
class AudioOutputRenameOutputRequest : public ClusterCommand
{
public:
    AudioOutputRenameOutputRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("rename-output-request", credsIssuerConfig)
    {
        AddArgument("Index", 0, UINT8_MAX, &mRequest.index);
        AddArgument("Name", &mRequest.name);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050B) command (0x00000001) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050B, 0x00000001, mRequest);
    }

private:
    chip::app::Clusters::AudioOutput::Commands::RenameOutputRequest::Type mRequest;
};

/*
 * Command SelectOutputRequest
 */
class AudioOutputSelectOutputRequest : public ClusterCommand
{
public:
    AudioOutputSelectOutputRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("select-output-request", credsIssuerConfig)
    {
        AddArgument("Index", 0, UINT8_MAX, &mRequest.index);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050B) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050B, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::AudioOutput::Commands::SelectOutputRequest::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster BarrierControl                                              | 0x0103 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * BarrierControlGoToPercent                                         |   0x00 |
| * BarrierControlStop                                                |   0x01 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * BarrierMovingState                                                | 0x0001 |
| * BarrierSafetyStatus                                               | 0x0002 |
| * BarrierCapabilities                                               | 0x0003 |
| * BarrierPosition                                                   | 0x000A |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command BarrierControlGoToPercent
 */
class BarrierControlBarrierControlGoToPercent : public ClusterCommand
{
public:
    BarrierControlBarrierControlGoToPercent(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("barrier-control-go-to-percent", credsIssuerConfig)
    {
        AddArgument("PercentOpen", 0, UINT8_MAX, &mRequest.percentOpen);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000103) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000103, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::BarrierControl::Commands::BarrierControlGoToPercent::Type mRequest;
};

/*
 * Command BarrierControlStop
 */
class BarrierControlBarrierControlStop : public ClusterCommand
{
public:
    BarrierControlBarrierControlStop(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("barrier-control-stop", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000103) command (0x00000001) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000103, 0x00000001, mRequest);
    }

private:
    chip::app::Clusters::BarrierControl::Commands::BarrierControlStop::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster Basic                                                       | 0x0028 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * DataModelRevision                                                 | 0x0000 |
| * VendorName                                                        | 0x0001 |
| * VendorID                                                          | 0x0002 |
| * ProductName                                                       | 0x0003 |
| * ProductID                                                         | 0x0004 |
| * NodeLabel                                                         | 0x0005 |
| * Location                                                          | 0x0006 |
| * HardwareVersion                                                   | 0x0007 |
| * HardwareVersionString                                             | 0x0008 |
| * SoftwareVersion                                                   | 0x0009 |
| * SoftwareVersionString                                             | 0x000A |
| * ManufacturingDate                                                 | 0x000B |
| * PartNumber                                                        | 0x000C |
| * ProductURL                                                        | 0x000D |
| * ProductLabel                                                      | 0x000E |
| * SerialNumber                                                      | 0x000F |
| * LocalConfigDisabled                                               | 0x0010 |
| * Reachable                                                         | 0x0011 |
| * UniqueID                                                          | 0x0012 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * StartUp                                                           | 0x0000 |
| * ShutDown                                                          | 0x0001 |
| * Leave                                                             | 0x0002 |
| * ReachableChanged                                                  | 0x0003 |
\*----------------------------------------------------------------------------*/

class WriteBasicNodeLabel : public WriteAttribute
{
public:
    WriteBasicNodeLabel(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("NodeLabel", credsIssuerConfig)
    {
        AddArgument("attr-name", "node-label");
        AddArgument("attr-value", &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteBasicNodeLabel() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000028, 0x00000005, mValue);
    }

private:
    chip::CharSpan mValue;
};

class WriteBasicLocation : public WriteAttribute
{
public:
    WriteBasicLocation(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Location", credsIssuerConfig)
    {
        AddArgument("attr-name", "location");
        AddArgument("attr-value", &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteBasicLocation() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000028, 0x00000006, mValue);
    }

private:
    chip::CharSpan mValue;
};

class WriteBasicLocalConfigDisabled : public WriteAttribute
{
public:
    WriteBasicLocalConfigDisabled(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("LocalConfigDisabled", credsIssuerConfig)
    {
        AddArgument("attr-name", "local-config-disabled");
        AddArgument("attr-value", 0, 1, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteBasicLocalConfigDisabled() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000028, 0x00000010, mValue);
    }

private:
    bool mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster BinaryInputBasic                                            | 0x000F |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * OutOfService                                                      | 0x0051 |
| * PresentValue                                                      | 0x0055 |
| * StatusFlags                                                       | 0x006F |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

class WriteBinaryInputBasicOutOfService : public WriteAttribute
{
public:
    WriteBinaryInputBasicOutOfService(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("OutOfService", credsIssuerConfig)
    {
        AddArgument("attr-name", "out-of-service");
        AddArgument("attr-value", 0, 1, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteBinaryInputBasicOutOfService() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000000F, 0x00000051, mValue);
    }

private:
    bool mValue;
};

class WriteBinaryInputBasicPresentValue : public WriteAttribute
{
public:
    WriteBinaryInputBasicPresentValue(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("PresentValue", credsIssuerConfig)
    {
        AddArgument("attr-name", "present-value");
        AddArgument("attr-value", 0, 1, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteBinaryInputBasicPresentValue() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000000F, 0x00000055, mValue);
    }

private:
    bool mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster Binding                                                     | 0x001E |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * BindingList                                                       | 0x0000 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

class WriteBindingBindingList : public WriteAttribute
{
public:
    WriteBindingBindingList(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("BindingList", credsIssuerConfig), mComplex(&mValue)
    {
        AddArgument("attr-name", "binding-list");
        AddArgument("attr-value", &mComplex);
        WriteAttribute::AddArguments();
    }

    ~WriteBindingBindingList() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000001E, 0x00000000, mValue);
    }

private:
    chip::app::DataModel::List<const chip::app::Clusters::Binding::Structs::BindingEntry::Type> mValue;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::Binding::Structs::BindingEntry::Type>> mComplex;
};

/*----------------------------------------------------------------------------*\
| Cluster BooleanState                                                | 0x0045 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * StateValue                                                        | 0x0000 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * StateChange                                                       | 0x0000 |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster BridgedActions                                              | 0x0025 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * DisableAction                                                     |   0x0A |
| * DisableActionWithDuration                                         |   0x0B |
| * EnableAction                                                      |   0x08 |
| * EnableActionWithDuration                                          |   0x09 |
| * InstantAction                                                     |   0x00 |
| * InstantActionWithTransition                                       |   0x01 |
| * PauseAction                                                       |   0x05 |
| * PauseActionWithDuration                                           |   0x06 |
| * ResumeAction                                                      |   0x07 |
| * StartAction                                                       |   0x02 |
| * StartActionWithDuration                                           |   0x03 |
| * StopAction                                                        |   0x04 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * ActionList                                                        | 0x0000 |
| * EndpointList                                                      | 0x0001 |
| * SetupUrl                                                          | 0x0002 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * StateChanged                                                      | 0x0000 |
| * ActionFailed                                                      | 0x0001 |
\*----------------------------------------------------------------------------*/

/*
 * Command DisableAction
 */
class BridgedActionsDisableAction : public ClusterCommand
{
public:
    BridgedActionsDisableAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("disable-action", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x0000000A) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x0000000A, mRequest);
    }

private:
    chip::app::Clusters::BridgedActions::Commands::DisableAction::Type mRequest;
};

/*
 * Command DisableActionWithDuration
 */
class BridgedActionsDisableActionWithDuration : public ClusterCommand
{
public:
    BridgedActionsDisableActionWithDuration(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("disable-action-with-duration", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        AddArgument("Duration", 0, UINT32_MAX, &mRequest.duration);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x0000000B) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x0000000B, mRequest);
    }

private:
    chip::app::Clusters::BridgedActions::Commands::DisableActionWithDuration::Type mRequest;
};

/*
 * Command EnableAction
 */
class BridgedActionsEnableAction : public ClusterCommand
{
public:
    BridgedActionsEnableAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("enable-action", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000008) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000008, mRequest);
    }

private:
    chip::app::Clusters::BridgedActions::Commands::EnableAction::Type mRequest;
};

/*
 * Command EnableActionWithDuration
 */
class BridgedActionsEnableActionWithDuration : public ClusterCommand
{
public:
    BridgedActionsEnableActionWithDuration(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("enable-action-with-duration", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        AddArgument("Duration", 0, UINT32_MAX, &mRequest.duration);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000009) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000009, mRequest);
    }

private:
    chip::app::Clusters::BridgedActions::Commands::EnableActionWithDuration::Type mRequest;
};

/*
 * Command InstantAction
 */
class BridgedActionsInstantAction : public ClusterCommand
{
public:
    BridgedActionsInstantAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("instant-action", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::BridgedActions::Commands::InstantAction::Type mRequest;
};

/*
 * Command InstantActionWithTransition
 */
class BridgedActionsInstantActionWithTransition : public ClusterCommand
{
public:
    BridgedActionsInstantActionWithTransition(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("instant-action-with-transition", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000001) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000001, mRequest);
    }

private:
    chip::app::Clusters::BridgedActions::Commands::InstantActionWithTransition::Type mRequest;
};

/*
 * Command PauseAction
 */
class BridgedActionsPauseAction : public ClusterCommand
{
public:
    BridgedActionsPauseAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("pause-action", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000005) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000005, mRequest);
    }

private:
    chip::app::Clusters::BridgedActions::Commands::PauseAction::Type mRequest;
};

/*
 * Command PauseActionWithDuration
 */
class BridgedActionsPauseActionWithDuration : public ClusterCommand
{
public:
    BridgedActionsPauseActionWithDuration(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("pause-action-with-duration", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        AddArgument("Duration", 0, UINT32_MAX, &mRequest.duration);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000006) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000006, mRequest);
    }

private:
    chip::app::Clusters::BridgedActions::Commands::PauseActionWithDuration::Type mRequest;
};

/*
 * Command ResumeAction
 */
class BridgedActionsResumeAction : public ClusterCommand
{
public:
    BridgedActionsResumeAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("resume-action", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000007) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000007, mRequest);
    }

private:
    chip::app::Clusters::BridgedActions::Commands::ResumeAction::Type mRequest;
};

/*
 * Command StartAction
 */
class BridgedActionsStartAction : public ClusterCommand
{
public:
    BridgedActionsStartAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("start-action", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000002) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000002, mRequest);
    }

private:
    chip::app::Clusters::BridgedActions::Commands::StartAction::Type mRequest;
};

/*
 * Command StartActionWithDuration
 */
class BridgedActionsStartActionWithDuration : public ClusterCommand
{
public:
    BridgedActionsStartActionWithDuration(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("start-action-with-duration", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        AddArgument("Duration", 0, UINT32_MAX, &mRequest.duration);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000003) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000003, mRequest);
    }

private:
    chip::app::Clusters::BridgedActions::Commands::StartActionWithDuration::Type mRequest;
};

/*
 * Command StopAction
 */
class BridgedActionsStopAction : public ClusterCommand
{
public:
    BridgedActionsStopAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop-action", credsIssuerConfig)
    {
        AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
        AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000004) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000004, mRequest);
    }

private:
    chip::app::Clusters::BridgedActions::Commands::StopAction::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster BridgedDeviceBasic                                          | 0x0039 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * VendorName                                                        | 0x0001 |
| * VendorID                                                          | 0x0002 |
| * ProductName                                                       | 0x0003 |
| * NodeLabel                                                         | 0x0005 |
| * HardwareVersion                                                   | 0x0007 |
| * HardwareVersionString                                             | 0x0008 |
| * SoftwareVersion                                                   | 0x0009 |
| * SoftwareVersionString                                             | 0x000A |
| * ManufacturingDate                                                 | 0x000B |
| * PartNumber                                                        | 0x000C |
| * ProductURL                                                        | 0x000D |
| * ProductLabel                                                      | 0x000E |
| * SerialNumber                                                      | 0x000F |
| * Reachable                                                         | 0x0011 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * StartUp                                                           | 0x0000 |
| * ShutDown                                                          | 0x0001 |
| * Leave                                                             | 0x0002 |
| * ReachableChanged                                                  | 0x0003 |
\*----------------------------------------------------------------------------*/

class WriteBridgedDeviceBasicNodeLabel : public WriteAttribute
{
public:
    WriteBridgedDeviceBasicNodeLabel(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("NodeLabel", credsIssuerConfig)
    {
        AddArgument("attr-name", "node-label");
        AddArgument("attr-value", &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteBridgedDeviceBasicNodeLabel() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000039, 0x00000005, mValue);
    }

private:
    chip::CharSpan mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster Channel                                                     | 0x0504 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ChangeChannelByNumberRequest                                      |   0x02 |
| * ChangeChannelRequest                                              |   0x00 |
| * SkipChannelRequest                                                |   0x03 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * ChannelList                                                       | 0x0000 |
| * ChannelLineup                                                     | 0x0001 |
| * CurrentChannel                                                    | 0x0002 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ChangeChannelByNumberRequest
 */
class ChannelChangeChannelByNumberRequest : public ClusterCommand
{
public:
    ChannelChangeChannelByNumberRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("change-channel-by-number-request", credsIssuerConfig)
    {
        AddArgument("MajorNumber", 0, UINT16_MAX, &mRequest.majorNumber);
        AddArgument("MinorNumber", 0, UINT16_MAX, &mRequest.minorNumber);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000504) command (0x00000002) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000504, 0x00000002, mRequest);
    }

private:
    chip::app::Clusters::Channel::Commands::ChangeChannelByNumberRequest::Type mRequest;
};

/*
 * Command ChangeChannelRequest
 */
class ChannelChangeChannelRequest : public ClusterCommand
{
public:
    ChannelChangeChannelRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("change-channel-request", credsIssuerConfig)
    {
        AddArgument("Match", &mRequest.match);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000504) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000504, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::Channel::Commands::ChangeChannelRequest::Type mRequest;
};

/*
 * Command SkipChannelRequest
 */
class ChannelSkipChannelRequest : public ClusterCommand
{
public:
    ChannelSkipChannelRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("skip-channel-request", credsIssuerConfig)
    {
        AddArgument("Count", 0, UINT16_MAX, &mRequest.count);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000504) command (0x00000003) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000504, 0x00000003, mRequest);
    }

private:
    chip::app::Clusters::Channel::Commands::SkipChannelRequest::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster ColorControl                                                | 0x0300 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ColorLoopSet                                                      |   0x44 |
| * EnhancedMoveHue                                                   |   0x41 |
| * EnhancedMoveToHue                                                 |   0x40 |
| * EnhancedMoveToHueAndSaturation                                    |   0x43 |
| * EnhancedStepHue                                                   |   0x42 |
| * MoveColor                                                         |   0x08 |
| * MoveColorTemperature                                              |   0x4B |
| * MoveHue                                                           |   0x01 |
| * MoveSaturation                                                    |   0x04 |
| * MoveToColor                                                       |   0x07 |
| * MoveToColorTemperature                                            |   0x0A |
| * MoveToHue                                                         |   0x00 |
| * MoveToHueAndSaturation                                            |   0x06 |
| * MoveToSaturation                                                  |   0x03 |
| * StepColor                                                         |   0x09 |
| * StepColorTemperature                                              |   0x4C |
| * StepHue                                                           |   0x02 |
| * StepSaturation                                                    |   0x05 |
| * StopMoveStep                                                      |   0x47 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * CurrentHue                                                        | 0x0000 |
| * CurrentSaturation                                                 | 0x0001 |
| * RemainingTime                                                     | 0x0002 |
| * CurrentX                                                          | 0x0003 |
| * CurrentY                                                          | 0x0004 |
| * DriftCompensation                                                 | 0x0005 |
| * CompensationText                                                  | 0x0006 |
| * ColorTemperature                                                  | 0x0007 |
| * ColorMode                                                         | 0x0008 |
| * ColorControlOptions                                               | 0x000F |
| * NumberOfPrimaries                                                 | 0x0010 |
| * Primary1X                                                         | 0x0011 |
| * Primary1Y                                                         | 0x0012 |
| * Primary1Intensity                                                 | 0x0013 |
| * Primary2X                                                         | 0x0015 |
| * Primary2Y                                                         | 0x0016 |
| * Primary2Intensity                                                 | 0x0017 |
| * Primary3X                                                         | 0x0019 |
| * Primary3Y                                                         | 0x001A |
| * Primary3Intensity                                                 | 0x001B |
| * Primary4X                                                         | 0x0020 |
| * Primary4Y                                                         | 0x0021 |
| * Primary4Intensity                                                 | 0x0022 |
| * Primary5X                                                         | 0x0024 |
| * Primary5Y                                                         | 0x0025 |
| * Primary5Intensity                                                 | 0x0026 |
| * Primary6X                                                         | 0x0028 |
| * Primary6Y                                                         | 0x0029 |
| * Primary6Intensity                                                 | 0x002A |
| * WhitePointX                                                       | 0x0030 |
| * WhitePointY                                                       | 0x0031 |
| * ColorPointRX                                                      | 0x0032 |
| * ColorPointRY                                                      | 0x0033 |
| * ColorPointRIntensity                                              | 0x0034 |
| * ColorPointGX                                                      | 0x0036 |
| * ColorPointGY                                                      | 0x0037 |
| * ColorPointGIntensity                                              | 0x0038 |
| * ColorPointBX                                                      | 0x003A |
| * ColorPointBY                                                      | 0x003B |
| * ColorPointBIntensity                                              | 0x003C |
| * EnhancedCurrentHue                                                | 0x4000 |
| * EnhancedColorMode                                                 | 0x4001 |
| * ColorLoopActive                                                   | 0x4002 |
| * ColorLoopDirection                                                | 0x4003 |
| * ColorLoopTime                                                     | 0x4004 |
| * ColorLoopStartEnhancedHue                                         | 0x4005 |
| * ColorLoopStoredEnhancedHue                                        | 0x4006 |
| * ColorCapabilities                                                 | 0x400A |
| * ColorTempPhysicalMin                                              | 0x400B |
| * ColorTempPhysicalMax                                              | 0x400C |
| * CoupleColorTempToLevelMinMireds                                   | 0x400D |
| * StartUpColorTemperatureMireds                                     | 0x4010 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ColorLoopSet
 */
class ColorControlColorLoopSet : public ClusterCommand
{
public:
    ColorControlColorLoopSet(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("color-loop-set", credsIssuerConfig)
    {
        AddArgument("UpdateFlags", 0, UINT8_MAX, &mRequest.updateFlags);
        AddArgument("Action", 0, UINT8_MAX, &mRequest.action);
        AddArgument("Direction", 0, UINT8_MAX, &mRequest.direction);
        AddArgument("Time", 0, UINT16_MAX, &mRequest.time);
        AddArgument("StartHue", 0, UINT16_MAX, &mRequest.startHue);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000044) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000044, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::ColorLoopSet::Type mRequest;
};

/*
 * Command EnhancedMoveHue
 */
class ColorControlEnhancedMoveHue : public ClusterCommand
{
public:
    ColorControlEnhancedMoveHue(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("enhanced-move-hue", credsIssuerConfig)
    {
        AddArgument("MoveMode", 0, UINT8_MAX, &mRequest.moveMode);
        AddArgument("Rate", 0, UINT16_MAX, &mRequest.rate);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000041) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000041, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::EnhancedMoveHue::Type mRequest;
};

/*
 * Command EnhancedMoveToHue
 */
class ColorControlEnhancedMoveToHue : public ClusterCommand
{
public:
    ColorControlEnhancedMoveToHue(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("enhanced-move-to-hue", credsIssuerConfig)
    {
        AddArgument("EnhancedHue", 0, UINT16_MAX, &mRequest.enhancedHue);
        AddArgument("Direction", 0, UINT8_MAX, &mRequest.direction);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000040) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000040, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::EnhancedMoveToHue::Type mRequest;
};

/*
 * Command EnhancedMoveToHueAndSaturation
 */
class ColorControlEnhancedMoveToHueAndSaturation : public ClusterCommand
{
public:
    ColorControlEnhancedMoveToHueAndSaturation(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("enhanced-move-to-hue-and-saturation", credsIssuerConfig)
    {
        AddArgument("EnhancedHue", 0, UINT16_MAX, &mRequest.enhancedHue);
        AddArgument("Saturation", 0, UINT8_MAX, &mRequest.saturation);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000043) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000043, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::EnhancedMoveToHueAndSaturation::Type mRequest;
};

/*
 * Command EnhancedStepHue
 */
class ColorControlEnhancedStepHue : public ClusterCommand
{
public:
    ColorControlEnhancedStepHue(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("enhanced-step-hue", credsIssuerConfig)
    {
        AddArgument("StepMode", 0, UINT8_MAX, &mRequest.stepMode);
        AddArgument("StepSize", 0, UINT16_MAX, &mRequest.stepSize);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000042) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000042, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::EnhancedStepHue::Type mRequest;
};

/*
 * Command MoveColor
 */
class ColorControlMoveColor : public ClusterCommand
{
public:
    ColorControlMoveColor(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-color", credsIssuerConfig)
    {
        AddArgument("RateX", INT16_MIN, INT16_MAX, &mRequest.rateX);
        AddArgument("RateY", INT16_MIN, INT16_MAX, &mRequest.rateY);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000008) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000008, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::MoveColor::Type mRequest;
};

/*
 * Command MoveColorTemperature
 */
class ColorControlMoveColorTemperature : public ClusterCommand
{
public:
    ColorControlMoveColorTemperature(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("move-color-temperature", credsIssuerConfig)
    {
        AddArgument("MoveMode", 0, UINT8_MAX, &mRequest.moveMode);
        AddArgument("Rate", 0, UINT16_MAX, &mRequest.rate);
        AddArgument("ColorTemperatureMinimum", 0, UINT16_MAX, &mRequest.colorTemperatureMinimum);
        AddArgument("ColorTemperatureMaximum", 0, UINT16_MAX, &mRequest.colorTemperatureMaximum);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x0000004B) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x0000004B, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::MoveColorTemperature::Type mRequest;
};

/*
 * Command MoveHue
 */
class ColorControlMoveHue : public ClusterCommand
{
public:
    ColorControlMoveHue(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-hue", credsIssuerConfig)
    {
        AddArgument("MoveMode", 0, UINT8_MAX, &mRequest.moveMode);
        AddArgument("Rate", 0, UINT8_MAX, &mRequest.rate);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000001) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000001, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::MoveHue::Type mRequest;
};

/*
 * Command MoveSaturation
 */
class ColorControlMoveSaturation : public ClusterCommand
{
public:
    ColorControlMoveSaturation(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-saturation", credsIssuerConfig)
    {
        AddArgument("MoveMode", 0, UINT8_MAX, &mRequest.moveMode);
        AddArgument("Rate", 0, UINT8_MAX, &mRequest.rate);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000004) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000004, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::MoveSaturation::Type mRequest;
};

/*
 * Command MoveToColor
 */
class ColorControlMoveToColor : public ClusterCommand
{
public:
    ColorControlMoveToColor(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-to-color", credsIssuerConfig)
    {
        AddArgument("ColorX", 0, UINT16_MAX, &mRequest.colorX);
        AddArgument("ColorY", 0, UINT16_MAX, &mRequest.colorY);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000007) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000007, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::MoveToColor::Type mRequest;
};

/*
 * Command MoveToColorTemperature
 */
class ColorControlMoveToColorTemperature : public ClusterCommand
{
public:
    ColorControlMoveToColorTemperature(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("move-to-color-temperature", credsIssuerConfig)
    {
        AddArgument("ColorTemperature", 0, UINT16_MAX, &mRequest.colorTemperature);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x0000000A) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x0000000A, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::MoveToColorTemperature::Type mRequest;
};

/*
 * Command MoveToHue
 */
class ColorControlMoveToHue : public ClusterCommand
{
public:
    ColorControlMoveToHue(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-to-hue", credsIssuerConfig)
    {
        AddArgument("Hue", 0, UINT8_MAX, &mRequest.hue);
        AddArgument("Direction", 0, UINT8_MAX, &mRequest.direction);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::MoveToHue::Type mRequest;
};

/*
 * Command MoveToHueAndSaturation
 */
class ColorControlMoveToHueAndSaturation : public ClusterCommand
{
public:
    ColorControlMoveToHueAndSaturation(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("move-to-hue-and-saturation", credsIssuerConfig)
    {
        AddArgument("Hue", 0, UINT8_MAX, &mRequest.hue);
        AddArgument("Saturation", 0, UINT8_MAX, &mRequest.saturation);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000006) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000006, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::MoveToHueAndSaturation::Type mRequest;
};

/*
 * Command MoveToSaturation
 */
class ColorControlMoveToSaturation : public ClusterCommand
{
public:
    ColorControlMoveToSaturation(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("move-to-saturation", credsIssuerConfig)
    {
        AddArgument("Saturation", 0, UINT8_MAX, &mRequest.saturation);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000003) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000003, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::MoveToSaturation::Type mRequest;
};

/*
 * Command StepColor
 */
class ColorControlStepColor : public ClusterCommand
{
public:
    ColorControlStepColor(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("step-color", credsIssuerConfig)
    {
        AddArgument("StepX", INT16_MIN, INT16_MAX, &mRequest.stepX);
        AddArgument("StepY", INT16_MIN, INT16_MAX, &mRequest.stepY);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000009) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000009, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::StepColor::Type mRequest;
};

/*
 * Command StepColorTemperature
 */
class ColorControlStepColorTemperature : public ClusterCommand
{
public:
    ColorControlStepColorTemperature(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("step-color-temperature", credsIssuerConfig)
    {
        AddArgument("StepMode", 0, UINT8_MAX, &mRequest.stepMode);
        AddArgument("StepSize", 0, UINT16_MAX, &mRequest.stepSize);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("ColorTemperatureMinimum", 0, UINT16_MAX, &mRequest.colorTemperatureMinimum);
        AddArgument("ColorTemperatureMaximum", 0, UINT16_MAX, &mRequest.colorTemperatureMaximum);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x0000004C) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x0000004C, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::StepColorTemperature::Type mRequest;
};

/*
 * Command StepHue
 */
class ColorControlStepHue : public ClusterCommand
{
public:
    ColorControlStepHue(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("step-hue", credsIssuerConfig)
    {
        AddArgument("StepMode", 0, UINT8_MAX, &mRequest.stepMode);
        AddArgument("StepSize", 0, UINT8_MAX, &mRequest.stepSize);
        AddArgument("TransitionTime", 0, UINT8_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000002) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000002, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::StepHue::Type mRequest;
};

/*
 * Command StepSaturation
 */
class ColorControlStepSaturation : public ClusterCommand
{
public:
    ColorControlStepSaturation(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("step-saturation", credsIssuerConfig)
    {
        AddArgument("StepMode", 0, UINT8_MAX, &mRequest.stepMode);
        AddArgument("StepSize", 0, UINT8_MAX, &mRequest.stepSize);
        AddArgument("TransitionTime", 0, UINT8_MAX, &mRequest.transitionTime);
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000005) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000005, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::StepSaturation::Type mRequest;
};

/*
 * Command StopMoveStep
 */
class ColorControlStopMoveStep : public ClusterCommand
{
public:
    ColorControlStopMoveStep(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop-move-step", credsIssuerConfig)
    {
        AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
        AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000047) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000047, mRequest);
    }

private:
    chip::app::Clusters::ColorControl::Commands::StopMoveStep::Type mRequest;
};

class WriteColorControlColorControlOptions : public WriteAttribute
{
public:
    WriteColorControlColorControlOptions(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("ColorControlOptions", credsIssuerConfig)
    {
        AddArgument("attr-name", "color-control-options");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteColorControlColorControlOptions() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x0000000F, mValue);
    }

private:
    uint8_t mValue;
};

class WriteColorControlWhitePointX : public WriteAttribute
{
public:
    WriteColorControlWhitePointX(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("WhitePointX", credsIssuerConfig)
    {
        AddArgument("attr-name", "white-point-x");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteColorControlWhitePointX() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x00000030, mValue);
    }

private:
    uint16_t mValue;
};

class WriteColorControlWhitePointY : public WriteAttribute
{
public:
    WriteColorControlWhitePointY(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("WhitePointY", credsIssuerConfig)
    {
        AddArgument("attr-name", "white-point-y");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteColorControlWhitePointY() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x00000031, mValue);
    }

private:
    uint16_t mValue;
};

class WriteColorControlColorPointRX : public WriteAttribute
{
public:
    WriteColorControlColorPointRX(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("ColorPointRX", credsIssuerConfig)
    {
        AddArgument("attr-name", "color-point-rx");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteColorControlColorPointRX() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x00000032, mValue);
    }

private:
    uint16_t mValue;
};

class WriteColorControlColorPointRY : public WriteAttribute
{
public:
    WriteColorControlColorPointRY(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("ColorPointRY", credsIssuerConfig)
    {
        AddArgument("attr-name", "color-point-ry");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteColorControlColorPointRY() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x00000033, mValue);
    }

private:
    uint16_t mValue;
};

class WriteColorControlColorPointRIntensity : public WriteAttribute
{
public:
    WriteColorControlColorPointRIntensity(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("ColorPointRIntensity", credsIssuerConfig)
    {
        AddArgument("attr-name", "color-point-rintensity");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteColorControlColorPointRIntensity() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x00000034, mValue);
    }

private:
    uint8_t mValue;
};

class WriteColorControlColorPointGX : public WriteAttribute
{
public:
    WriteColorControlColorPointGX(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("ColorPointGX", credsIssuerConfig)
    {
        AddArgument("attr-name", "color-point-gx");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteColorControlColorPointGX() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x00000036, mValue);
    }

private:
    uint16_t mValue;
};

class WriteColorControlColorPointGY : public WriteAttribute
{
public:
    WriteColorControlColorPointGY(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("ColorPointGY", credsIssuerConfig)
    {
        AddArgument("attr-name", "color-point-gy");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteColorControlColorPointGY() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x00000037, mValue);
    }

private:
    uint16_t mValue;
};

class WriteColorControlColorPointGIntensity : public WriteAttribute
{
public:
    WriteColorControlColorPointGIntensity(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("ColorPointGIntensity", credsIssuerConfig)
    {
        AddArgument("attr-name", "color-point-gintensity");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteColorControlColorPointGIntensity() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x00000038, mValue);
    }

private:
    uint8_t mValue;
};

class WriteColorControlColorPointBX : public WriteAttribute
{
public:
    WriteColorControlColorPointBX(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("ColorPointBX", credsIssuerConfig)
    {
        AddArgument("attr-name", "color-point-bx");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteColorControlColorPointBX() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x0000003A, mValue);
    }

private:
    uint16_t mValue;
};

class WriteColorControlColorPointBY : public WriteAttribute
{
public:
    WriteColorControlColorPointBY(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("ColorPointBY", credsIssuerConfig)
    {
        AddArgument("attr-name", "color-point-by");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteColorControlColorPointBY() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x0000003B, mValue);
    }

private:
    uint16_t mValue;
};

class WriteColorControlColorPointBIntensity : public WriteAttribute
{
public:
    WriteColorControlColorPointBIntensity(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("ColorPointBIntensity", credsIssuerConfig)
    {
        AddArgument("attr-name", "color-point-bintensity");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteColorControlColorPointBIntensity() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x0000003C, mValue);
    }

private:
    uint8_t mValue;
};

class WriteColorControlStartUpColorTemperatureMireds : public WriteAttribute
{
public:
    WriteColorControlStartUpColorTemperatureMireds(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("StartUpColorTemperatureMireds", credsIssuerConfig)
    {
        AddArgument("attr-name", "start-up-color-temperature-mireds");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteColorControlStartUpColorTemperatureMireds() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x00004010, mValue);
    }

private:
    uint16_t mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster ContentLauncher                                             | 0x050A |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * LaunchContentRequest                                              |   0x00 |
| * LaunchURLRequest                                                  |   0x01 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * AcceptHeaderList                                                  | 0x0000 |
| * SupportedStreamingProtocols                                       | 0x0001 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command LaunchContentRequest
 */
class ContentLauncherLaunchContentRequest : public ClusterCommand
{
public:
    ContentLauncherLaunchContentRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("launch-content-request", credsIssuerConfig), mComplex_Search(&mRequest.search)
    {
        AddArgument("Search", &mComplex_Search);
        AddArgument("AutoPlay", 0, 1, &mRequest.autoPlay);
        AddArgument("Data", &mRequest.data);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050A) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050A, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::ContentLauncher::Commands::LaunchContentRequest::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::ContentLauncher::Structs::ContentSearch::Type>>
        mComplex_Search;
};

/*
 * Command LaunchURLRequest
 */
class ContentLauncherLaunchURLRequest : public ClusterCommand
{
public:
    ContentLauncherLaunchURLRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("launch-urlrequest", credsIssuerConfig), mComplex_BrandingInformation(&mRequest.brandingInformation)
    {
        AddArgument("ContentURL", &mRequest.contentURL);
        AddArgument("DisplayString", &mRequest.displayString);
        AddArgument("BrandingInformation", &mComplex_BrandingInformation);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050A) command (0x00000001) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050A, 0x00000001, mRequest);
    }

private:
    chip::app::Clusters::ContentLauncher::Commands::LaunchURLRequest::Type mRequest;
    TypedComplexArgument<chip::Optional<chip::app::Clusters::ContentLauncher::Structs::BrandingInformation::Type>>
        mComplex_BrandingInformation;
};

class WriteContentLauncherSupportedStreamingProtocols : public WriteAttribute
{
public:
    WriteContentLauncherSupportedStreamingProtocols(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("SupportedStreamingProtocols", credsIssuerConfig)
    {
        AddArgument("attr-name", "supported-streaming-protocols");
        AddArgument("attr-value", 0, UINT32_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteContentLauncherSupportedStreamingProtocols() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050A, 0x00000001, mValue);
    }

private:
    uint32_t mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster Descriptor                                                  | 0x001D |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * DeviceList                                                        | 0x0000 |
| * ServerList                                                        | 0x0001 |
| * ClientList                                                        | 0x0002 |
| * PartsList                                                         | 0x0003 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster DiagnosticLogs                                              | 0x0032 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * RetrieveLogsRequest                                               |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command RetrieveLogsRequest
 */
class DiagnosticLogsRetrieveLogsRequest : public ClusterCommand
{
public:
    DiagnosticLogsRetrieveLogsRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("retrieve-logs-request", credsIssuerConfig)
    {
        AddArgument("Intent", 0, UINT8_MAX, &mRequest.intent);
        AddArgument("RequestedProtocol", 0, UINT8_MAX, &mRequest.requestedProtocol);
        AddArgument("TransferFileDesignator", &mRequest.transferFileDesignator);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000032) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000032, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::DiagnosticLogs::Commands::RetrieveLogsRequest::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster DoorLock                                                    | 0x0101 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ClearCredential                                                   |   0x26 |
| * ClearUser                                                         |   0x1D |
| * ClearWeekDaySchedule                                              |   0x0D |
| * ClearYearDaySchedule                                              |   0x10 |
| * GetCredentialStatus                                               |   0x24 |
| * GetUser                                                           |   0x1B |
| * GetWeekDaySchedule                                                |   0x0C |
| * GetYearDaySchedule                                                |   0x0F |
| * LockDoor                                                          |   0x00 |
| * SetCredential                                                     |   0x22 |
| * SetUser                                                           |   0x1A |
| * SetWeekDaySchedule                                                |   0x0B |
| * SetYearDaySchedule                                                |   0x0E |
| * UnlockDoor                                                        |   0x01 |
| * UnlockWithTimeout                                                 |   0x03 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * LockState                                                         | 0x0000 |
| * LockType                                                          | 0x0001 |
| * ActuatorEnabled                                                   | 0x0002 |
| * DoorState                                                         | 0x0003 |
| * NumberOfTotalUsersSupported                                       | 0x0011 |
| * NumberOfPINUsersSupported                                         | 0x0012 |
| * NumberOfRFIDUsersSupported                                        | 0x0013 |
| * NumberOfWeekDaySchedulesSupportedPerUser                          | 0x0014 |
| * NumberOfYearDaySchedulesSupportedPerUser                          | 0x0015 |
| * MaxPINCodeLength                                                  | 0x0017 |
| * MinPINCodeLength                                                  | 0x0018 |
| * MaxRFIDCodeLength                                                 | 0x0019 |
| * MinRFIDCodeLength                                                 | 0x001A |
| * Language                                                          | 0x0021 |
| * AutoRelockTime                                                    | 0x0023 |
| * SoundVolume                                                       | 0x0024 |
| * OperatingMode                                                     | 0x0025 |
| * SupportedOperatingModes                                           | 0x0026 |
| * EnableOneTouchLocking                                             | 0x0029 |
| * EnablePrivacyModeButton                                           | 0x002B |
| * WrongCodeEntryLimit                                               | 0x0030 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * DoorLockAlarm                                                     | 0x0000 |
| * DoorStateChange                                                   | 0x0001 |
| * LockOperation                                                     | 0x0002 |
| * LockOperationError                                                | 0x0003 |
| * LockUserChange                                                    | 0x0004 |
\*----------------------------------------------------------------------------*/

/*
 * Command ClearCredential
 */
class DoorLockClearCredential : public ClusterCommand
{
public:
    DoorLockClearCredential(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("clear-credential", credsIssuerConfig), mComplex_Credential(&mRequest.credential)
    {
        AddArgument("Credential", &mComplex_Credential);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x00000026) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x00000026, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::ClearCredential::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::Structs::DlCredential::Type>>
        mComplex_Credential;
};

/*
 * Command ClearUser
 */
class DoorLockClearUser : public ClusterCommand
{
public:
    DoorLockClearUser(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("clear-user", credsIssuerConfig)
    {
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x0000001D) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x0000001D, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::ClearUser::Type mRequest;
};

/*
 * Command ClearWeekDaySchedule
 */
class DoorLockClearWeekDaySchedule : public ClusterCommand
{
public:
    DoorLockClearWeekDaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("clear-week-day-schedule", credsIssuerConfig)
    {
        AddArgument("WeekDayIndex", 0, UINT8_MAX, &mRequest.weekDayIndex);
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x0000000D) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x0000000D, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::ClearWeekDaySchedule::Type mRequest;
};

/*
 * Command ClearYearDaySchedule
 */
class DoorLockClearYearDaySchedule : public ClusterCommand
{
public:
    DoorLockClearYearDaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("clear-year-day-schedule", credsIssuerConfig)
    {
        AddArgument("YearDayIndex", 0, UINT8_MAX, &mRequest.yearDayIndex);
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x00000010) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x00000010, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::ClearYearDaySchedule::Type mRequest;
};

/*
 * Command GetCredentialStatus
 */
class DoorLockGetCredentialStatus : public ClusterCommand
{
public:
    DoorLockGetCredentialStatus(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("get-credential-status", credsIssuerConfig), mComplex_Credential(&mRequest.credential)
    {
        AddArgument("Credential", &mComplex_Credential);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x00000024) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x00000024, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::GetCredentialStatus::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::DoorLock::Structs::DlCredential::Type> mComplex_Credential;
};

/*
 * Command GetUser
 */
class DoorLockGetUser : public ClusterCommand
{
public:
    DoorLockGetUser(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("get-user", credsIssuerConfig)
    {
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x0000001B) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x0000001B, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::GetUser::Type mRequest;
};

/*
 * Command GetWeekDaySchedule
 */
class DoorLockGetWeekDaySchedule : public ClusterCommand
{
public:
    DoorLockGetWeekDaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("get-week-day-schedule", credsIssuerConfig)
    {
        AddArgument("WeekDayIndex", 0, UINT8_MAX, &mRequest.weekDayIndex);
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x0000000C) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x0000000C, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::GetWeekDaySchedule::Type mRequest;
};

/*
 * Command GetYearDaySchedule
 */
class DoorLockGetYearDaySchedule : public ClusterCommand
{
public:
    DoorLockGetYearDaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("get-year-day-schedule", credsIssuerConfig)
    {
        AddArgument("YearDayIndex", 0, UINT8_MAX, &mRequest.yearDayIndex);
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x0000000F) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x0000000F, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::GetYearDaySchedule::Type mRequest;
};

/*
 * Command LockDoor
 */
class DoorLockLockDoor : public ClusterCommand
{
public:
    DoorLockLockDoor(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("lock-door", credsIssuerConfig)
    {
        AddArgument("PinCode", &mRequest.pinCode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::LockDoor::Type mRequest;
};

/*
 * Command SetCredential
 */
class DoorLockSetCredential : public ClusterCommand
{
public:
    DoorLockSetCredential(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-credential", credsIssuerConfig), mComplex_Credential(&mRequest.credential)
    {
        AddArgument("OperationType", 0, UINT8_MAX, &mRequest.operationType);
        AddArgument("Credential", &mComplex_Credential);
        AddArgument("CredentialData", &mRequest.credentialData);
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        AddArgument("UserStatus", 0, UINT8_MAX, &mRequest.userStatus);
        AddArgument("UserType", 0, UINT8_MAX, &mRequest.userType);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x00000022) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x00000022, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::SetCredential::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::DoorLock::Structs::DlCredential::Type> mComplex_Credential;
};

/*
 * Command SetUser
 */
class DoorLockSetUser : public ClusterCommand
{
public:
    DoorLockSetUser(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("set-user", credsIssuerConfig)
    {
        AddArgument("OperationType", 0, UINT8_MAX, &mRequest.operationType);
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        AddArgument("UserName", &mRequest.userName);
        AddArgument("UserUniqueId", 0, UINT32_MAX, &mRequest.userUniqueId);
        AddArgument("UserStatus", 0, UINT8_MAX, &mRequest.userStatus);
        AddArgument("UserType", 0, UINT8_MAX, &mRequest.userType);
        AddArgument("CredentialRule", 0, UINT8_MAX, &mRequest.credentialRule);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x0000001A) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x0000001A, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::SetUser::Type mRequest;
};

/*
 * Command SetWeekDaySchedule
 */
class DoorLockSetWeekDaySchedule : public ClusterCommand
{
public:
    DoorLockSetWeekDaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-week-day-schedule", credsIssuerConfig)
    {
        AddArgument("WeekDayIndex", 0, UINT8_MAX, &mRequest.weekDayIndex);
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        AddArgument("DaysMask", 0, UINT8_MAX, &mRequest.daysMask);
        AddArgument("StartHour", 0, UINT8_MAX, &mRequest.startHour);
        AddArgument("StartMinute", 0, UINT8_MAX, &mRequest.startMinute);
        AddArgument("EndHour", 0, UINT8_MAX, &mRequest.endHour);
        AddArgument("EndMinute", 0, UINT8_MAX, &mRequest.endMinute);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x0000000B) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x0000000B, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::SetWeekDaySchedule::Type mRequest;
};

/*
 * Command SetYearDaySchedule
 */
class DoorLockSetYearDaySchedule : public ClusterCommand
{
public:
    DoorLockSetYearDaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-year-day-schedule", credsIssuerConfig)
    {
        AddArgument("YearDayIndex", 0, UINT8_MAX, &mRequest.yearDayIndex);
        AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
        AddArgument("LocalStartTime", 0, UINT32_MAX, &mRequest.localStartTime);
        AddArgument("LocalEndTime", 0, UINT32_MAX, &mRequest.localEndTime);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x0000000E) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x0000000E, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::SetYearDaySchedule::Type mRequest;
};

/*
 * Command UnlockDoor
 */
class DoorLockUnlockDoor : public ClusterCommand
{
public:
    DoorLockUnlockDoor(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("unlock-door", credsIssuerConfig)
    {
        AddArgument("PinCode", &mRequest.pinCode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x00000001) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x00000001, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::UnlockDoor::Type mRequest;
};

/*
 * Command UnlockWithTimeout
 */
class DoorLockUnlockWithTimeout : public ClusterCommand
{
public:
    DoorLockUnlockWithTimeout(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("unlock-with-timeout", credsIssuerConfig)
    {
        AddArgument("Timeout", 0, UINT16_MAX, &mRequest.timeout);
        AddArgument("PinCode", &mRequest.pinCode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x00000003) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x00000003, mRequest);
    }

private:
    chip::app::Clusters::DoorLock::Commands::UnlockWithTimeout::Type mRequest;
};

class WriteDoorLockLanguage : public WriteAttribute
{
public:
    WriteDoorLockLanguage(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Language", credsIssuerConfig)
    {
        AddArgument("attr-name", "language");
        AddArgument("attr-value", &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteDoorLockLanguage() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000101, 0x00000021, mValue);
    }

private:
    chip::CharSpan mValue;
};

class WriteDoorLockAutoRelockTime : public WriteAttribute
{
public:
    WriteDoorLockAutoRelockTime(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("AutoRelockTime", credsIssuerConfig)
    {
        AddArgument("attr-name", "auto-relock-time");
        AddArgument("attr-value", 0, UINT32_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteDoorLockAutoRelockTime() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000101, 0x00000023, mValue);
    }

private:
    uint32_t mValue;
};

class WriteDoorLockSoundVolume : public WriteAttribute
{
public:
    WriteDoorLockSoundVolume(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("SoundVolume", credsIssuerConfig)
    {
        AddArgument("attr-name", "sound-volume");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteDoorLockSoundVolume() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000101, 0x00000024, mValue);
    }

private:
    uint8_t mValue;
};

class WriteDoorLockOperatingMode : public WriteAttribute
{
public:
    WriteDoorLockOperatingMode(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("OperatingMode", credsIssuerConfig)
    {
        AddArgument("attr-name", "operating-mode");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteDoorLockOperatingMode() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000101, 0x00000025, mValue);
    }

private:
    chip::app::Clusters::DoorLock::DlOperatingMode mValue;
};

class WriteDoorLockEnableOneTouchLocking : public WriteAttribute
{
public:
    WriteDoorLockEnableOneTouchLocking(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("EnableOneTouchLocking", credsIssuerConfig)
    {
        AddArgument("attr-name", "enable-one-touch-locking");
        AddArgument("attr-value", 0, 1, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteDoorLockEnableOneTouchLocking() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000101, 0x00000029, mValue);
    }

private:
    bool mValue;
};

class WriteDoorLockEnablePrivacyModeButton : public WriteAttribute
{
public:
    WriteDoorLockEnablePrivacyModeButton(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("EnablePrivacyModeButton", credsIssuerConfig)
    {
        AddArgument("attr-name", "enable-privacy-mode-button");
        AddArgument("attr-value", 0, 1, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteDoorLockEnablePrivacyModeButton() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000101, 0x0000002B, mValue);
    }

private:
    bool mValue;
};

class WriteDoorLockWrongCodeEntryLimit : public WriteAttribute
{
public:
    WriteDoorLockWrongCodeEntryLimit(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("WrongCodeEntryLimit", credsIssuerConfig)
    {
        AddArgument("attr-name", "wrong-code-entry-limit");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteDoorLockWrongCodeEntryLimit() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000101, 0x00000030, mValue);
    }

private:
    uint8_t mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster ElectricalMeasurement                                       | 0x0B04 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasurementType                                                   | 0x0000 |
| * TotalActivePower                                                  | 0x0304 |
| * RmsVoltage                                                        | 0x0505 |
| * RmsVoltageMin                                                     | 0x0506 |
| * RmsVoltageMax                                                     | 0x0507 |
| * RmsCurrent                                                        | 0x0508 |
| * RmsCurrentMin                                                     | 0x0509 |
| * RmsCurrentMax                                                     | 0x050A |
| * ActivePower                                                       | 0x050B |
| * ActivePowerMin                                                    | 0x050C |
| * ActivePowerMax                                                    | 0x050D |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster EthernetNetworkDiagnostics                                  | 0x0037 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ResetCounts                                                       |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * PHYRate                                                           | 0x0000 |
| * FullDuplex                                                        | 0x0001 |
| * PacketRxCount                                                     | 0x0002 |
| * PacketTxCount                                                     | 0x0003 |
| * TxErrCount                                                        | 0x0004 |
| * CollisionCount                                                    | 0x0005 |
| * OverrunCount                                                      | 0x0006 |
| * CarrierDetect                                                     | 0x0007 |
| * TimeSinceReset                                                    | 0x0008 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ResetCounts
 */
class EthernetNetworkDiagnosticsResetCounts : public ClusterCommand
{
public:
    EthernetNetworkDiagnosticsResetCounts(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("reset-counts", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000037) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000037, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::EthernetNetworkDiagnostics::Commands::ResetCounts::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster FixedLabel                                                  | 0x0040 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * LabelList                                                         | 0x0000 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster FlowMeasurement                                             | 0x0404 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * Tolerance                                                         | 0x0003 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster GeneralCommissioning                                        | 0x0030 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ArmFailSafe                                                       |   0x00 |
| * CommissioningComplete                                             |   0x04 |
| * SetRegulatoryConfig                                               |   0x02 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Breadcrumb                                                        | 0x0000 |
| * BasicCommissioningInfo                                            | 0x0001 |
| * RegulatoryConfig                                                  | 0x0002 |
| * LocationCapability                                                | 0x0003 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ArmFailSafe
 */
class GeneralCommissioningArmFailSafe : public ClusterCommand
{
public:
    GeneralCommissioningArmFailSafe(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("arm-fail-safe", credsIssuerConfig)
    {
        AddArgument("ExpiryLengthSeconds", 0, UINT16_MAX, &mRequest.expiryLengthSeconds);
        AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
        AddArgument("TimeoutMs", 0, UINT32_MAX, &mRequest.timeoutMs);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000030) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000030, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::GeneralCommissioning::Commands::ArmFailSafe::Type mRequest;
};

/*
 * Command CommissioningComplete
 */
class GeneralCommissioningCommissioningComplete : public ClusterCommand
{
public:
    GeneralCommissioningCommissioningComplete(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("commissioning-complete", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000030) command (0x00000004) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000030, 0x00000004, mRequest);
    }

private:
    chip::app::Clusters::GeneralCommissioning::Commands::CommissioningComplete::Type mRequest;
};

/*
 * Command SetRegulatoryConfig
 */
class GeneralCommissioningSetRegulatoryConfig : public ClusterCommand
{
public:
    GeneralCommissioningSetRegulatoryConfig(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-regulatory-config", credsIssuerConfig)
    {
        AddArgument("Location", 0, UINT8_MAX, &mRequest.location);
        AddArgument("CountryCode", &mRequest.countryCode);
        AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
        AddArgument("TimeoutMs", 0, UINT32_MAX, &mRequest.timeoutMs);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000030) command (0x00000002) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000030, 0x00000002, mRequest);
    }

private:
    chip::app::Clusters::GeneralCommissioning::Commands::SetRegulatoryConfig::Type mRequest;
};

class WriteGeneralCommissioningBreadcrumb : public WriteAttribute
{
public:
    WriteGeneralCommissioningBreadcrumb(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("Breadcrumb", credsIssuerConfig)
    {
        AddArgument("attr-name", "breadcrumb");
        AddArgument("attr-value", 0, UINT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteGeneralCommissioningBreadcrumb() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000030, 0x00000000, mValue);
    }

private:
    uint64_t mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster GeneralDiagnostics                                          | 0x0033 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * NetworkInterfaces                                                 | 0x0000 |
| * RebootCount                                                       | 0x0001 |
| * UpTime                                                            | 0x0002 |
| * TotalOperationalHours                                             | 0x0003 |
| * BootReasons                                                       | 0x0004 |
| * ActiveHardwareFaults                                              | 0x0005 |
| * ActiveRadioFaults                                                 | 0x0006 |
| * ActiveNetworkFaults                                               | 0x0007 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * HardwareFaultChange                                               | 0x0000 |
| * RadioFaultChange                                                  | 0x0001 |
| * NetworkFaultChange                                                | 0x0002 |
| * BootReason                                                        | 0x0003 |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster GroupKeyManagement                                          | 0x003F |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * KeySetRead                                                        |   0x01 |
| * KeySetReadAllIndices                                              |   0x04 |
| * KeySetRemove                                                      |   0x03 |
| * KeySetWrite                                                       |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * GroupKeyMap                                                       | 0x0000 |
| * GroupTable                                                        | 0x0001 |
| * MaxGroupsPerFabric                                                | 0x0002 |
| * MaxGroupKeysPerFabric                                             | 0x0003 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command KeySetRead
 */
class GroupKeyManagementKeySetRead : public ClusterCommand
{
public:
    GroupKeyManagementKeySetRead(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("key-set-read", credsIssuerConfig)
    {
        AddArgument("GroupKeySetID", 0, UINT16_MAX, &mRequest.groupKeySetID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000003F) command (0x00000001) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000003F, 0x00000001, mRequest);
    }

private:
    chip::app::Clusters::GroupKeyManagement::Commands::KeySetRead::Type mRequest;
};

/*
 * Command KeySetReadAllIndices
 */
class GroupKeyManagementKeySetReadAllIndices : public ClusterCommand
{
public:
    GroupKeyManagementKeySetReadAllIndices(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("key-set-read-all-indices", credsIssuerConfig), mComplex_GroupKeySetIDs(&mRequest.groupKeySetIDs)
    {
        AddArgument("GroupKeySetIDs", &mComplex_GroupKeySetIDs);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000003F) command (0x00000004) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000003F, 0x00000004, mRequest);
    }

private:
    chip::app::Clusters::GroupKeyManagement::Commands::KeySetReadAllIndices::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const uint16_t>> mComplex_GroupKeySetIDs;
};

/*
 * Command KeySetRemove
 */
class GroupKeyManagementKeySetRemove : public ClusterCommand
{
public:
    GroupKeyManagementKeySetRemove(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("key-set-remove", credsIssuerConfig)
    {
        AddArgument("GroupKeySetID", 0, UINT16_MAX, &mRequest.groupKeySetID);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000003F) command (0x00000003) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000003F, 0x00000003, mRequest);
    }

private:
    chip::app::Clusters::GroupKeyManagement::Commands::KeySetRemove::Type mRequest;
};

/*
 * Command KeySetWrite
 */
class GroupKeyManagementKeySetWrite : public ClusterCommand
{
public:
    GroupKeyManagementKeySetWrite(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("key-set-write", credsIssuerConfig), mComplex_GroupKeySet(&mRequest.groupKeySet)
    {
        AddArgument("GroupKeySet", &mComplex_GroupKeySet);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000003F) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000003F, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::GroupKeyManagement::Commands::KeySetWrite::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::GroupKeyManagement::Structs::GroupKeySetStruct::Type> mComplex_GroupKeySet;
};

class WriteGroupKeyManagementGroupKeyMap : public WriteAttribute
{
public:
    WriteGroupKeyManagementGroupKeyMap(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("GroupKeyMap", credsIssuerConfig), mComplex(&mValue)
    {
        AddArgument("attr-name", "group-key-map");
        AddArgument("attr-value", &mComplex);
        WriteAttribute::AddArguments();
    }

    ~WriteGroupKeyManagementGroupKeyMap() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000003F, 0x00000000, mValue);
    }

private:
    chip::app::DataModel::List<const chip::app::Clusters::GroupKeyManagement::Structs::GroupKeyMapStruct::Type> mValue;
    TypedComplexArgument<
        chip::app::DataModel::List<const chip::app::Clusters::GroupKeyManagement::Structs::GroupKeyMapStruct::Type>>
        mComplex;
};

/*----------------------------------------------------------------------------*\
| Cluster Groups                                                      | 0x0004 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * AddGroup                                                          |   0x00 |
| * AddGroupIfIdentifying                                             |   0x05 |
| * GetGroupMembership                                                |   0x02 |
| * RemoveAllGroups                                                   |   0x04 |
| * RemoveGroup                                                       |   0x03 |
| * ViewGroup                                                         |   0x01 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * NameSupport                                                       | 0x0000 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command AddGroup
 */
class GroupsAddGroup : public ClusterCommand
{
public:
    GroupsAddGroup(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("add-group", credsIssuerConfig)
    {
        AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
        AddArgument("GroupName", &mRequest.groupName);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000004) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000004, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::Groups::Commands::AddGroup::Type mRequest;
};

/*
 * Command AddGroupIfIdentifying
 */
class GroupsAddGroupIfIdentifying : public ClusterCommand
{
public:
    GroupsAddGroupIfIdentifying(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("add-group-if-identifying", credsIssuerConfig)
    {
        AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
        AddArgument("GroupName", &mRequest.groupName);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000004) command (0x00000005) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000004, 0x00000005, mRequest);
    }

private:
    chip::app::Clusters::Groups::Commands::AddGroupIfIdentifying::Type mRequest;
};

/*
 * Command GetGroupMembership
 */
class GroupsGetGroupMembership : public ClusterCommand
{
public:
    GroupsGetGroupMembership(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("get-group-membership", credsIssuerConfig), mComplex_GroupList(&mRequest.groupList)
    {
        AddArgument("GroupList", &mComplex_GroupList);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000004) command (0x00000002) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000004, 0x00000002, mRequest);
    }

private:
    chip::app::Clusters::Groups::Commands::GetGroupMembership::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const uint16_t>> mComplex_GroupList;
};

/*
 * Command RemoveAllGroups
 */
class GroupsRemoveAllGroups : public ClusterCommand
{
public:
    GroupsRemoveAllGroups(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("remove-all-groups", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000004) command (0x00000004) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000004, 0x00000004, mRequest);
    }

private:
    chip::app::Clusters::Groups::Commands::RemoveAllGroups::Type mRequest;
};

/*
 * Command RemoveGroup
 */
class GroupsRemoveGroup : public ClusterCommand
{
public:
    GroupsRemoveGroup(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("remove-group", credsIssuerConfig)
    {
        AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000004) command (0x00000003) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000004, 0x00000003, mRequest);
    }

private:
    chip::app::Clusters::Groups::Commands::RemoveGroup::Type mRequest;
};

/*
 * Command ViewGroup
 */
class GroupsViewGroup : public ClusterCommand
{
public:
    GroupsViewGroup(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("view-group", credsIssuerConfig)
    {
        AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000004) command (0x00000001) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000004, 0x00000001, mRequest);
    }

private:
    chip::app::Clusters::Groups::Commands::ViewGroup::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster Identify                                                    | 0x0003 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * Identify                                                          |   0x00 |
| * IdentifyQuery                                                     |   0x01 |
| * TriggerEffect                                                     |   0x40 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * IdentifyTime                                                      | 0x0000 |
| * IdentifyType                                                      | 0x0001 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command Identify
 */
class IdentifyIdentify : public ClusterCommand
{
public:
    IdentifyIdentify(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("identify", credsIssuerConfig)
    {
        AddArgument("IdentifyTime", 0, UINT16_MAX, &mRequest.identifyTime);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000003) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000003, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::Identify::Commands::Identify::Type mRequest;
};

/*
 * Command IdentifyQuery
 */
class IdentifyIdentifyQuery : public ClusterCommand
{
public:
    IdentifyIdentifyQuery(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("identify-query", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000003) command (0x00000001) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000003, 0x00000001, mRequest);
    }

private:
    chip::app::Clusters::Identify::Commands::IdentifyQuery::Type mRequest;
};

/*
 * Command TriggerEffect
 */
class IdentifyTriggerEffect : public ClusterCommand
{
public:
    IdentifyTriggerEffect(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("trigger-effect", credsIssuerConfig)
    {
        AddArgument("EffectIdentifier", 0, UINT8_MAX, &mRequest.effectIdentifier);
        AddArgument("EffectVariant", 0, UINT8_MAX, &mRequest.effectVariant);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000003) command (0x00000040) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000003, 0x00000040, mRequest);
    }

private:
    chip::app::Clusters::Identify::Commands::TriggerEffect::Type mRequest;
};

class WriteIdentifyIdentifyTime : public WriteAttribute
{
public:
    WriteIdentifyIdentifyTime(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("IdentifyTime", credsIssuerConfig)
    {
        AddArgument("attr-name", "identify-time");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteIdentifyIdentifyTime() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000003, 0x00000000, mValue);
    }

private:
    uint16_t mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster IlluminanceMeasurement                                      | 0x0400 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * Tolerance                                                         | 0x0003 |
| * LightSensorType                                                   | 0x0004 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster KeypadInput                                                 | 0x0509 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * SendKeyRequest                                                    |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command SendKeyRequest
 */
class KeypadInputSendKeyRequest : public ClusterCommand
{
public:
    KeypadInputSendKeyRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("send-key-request", credsIssuerConfig)
    {
        AddArgument("KeyCode", 0, UINT8_MAX, &mRequest.keyCode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000509) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000509, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::KeypadInput::Commands::SendKeyRequest::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster LevelControl                                                | 0x0008 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * Move                                                              |   0x01 |
| * MoveToLevel                                                       |   0x00 |
| * MoveToLevelWithOnOff                                              |   0x04 |
| * MoveWithOnOff                                                     |   0x05 |
| * Step                                                              |   0x02 |
| * StepWithOnOff                                                     |   0x06 |
| * Stop                                                              |   0x03 |
| * StopWithOnOff                                                     |   0x07 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * CurrentLevel                                                      | 0x0000 |
| * RemainingTime                                                     | 0x0001 |
| * MinLevel                                                          | 0x0002 |
| * MaxLevel                                                          | 0x0003 |
| * CurrentFrequency                                                  | 0x0004 |
| * MinFrequency                                                      | 0x0005 |
| * MaxFrequency                                                      | 0x0006 |
| * Options                                                           | 0x000F |
| * OnOffTransitionTime                                               | 0x0010 |
| * OnLevel                                                           | 0x0011 |
| * OnTransitionTime                                                  | 0x0012 |
| * OffTransitionTime                                                 | 0x0013 |
| * DefaultMoveRate                                                   | 0x0014 |
| * StartUpCurrentLevel                                               | 0x4000 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command Move
 */
class LevelControlMove : public ClusterCommand
{
public:
    LevelControlMove(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move", credsIssuerConfig)
    {
        AddArgument("MoveMode", 0, UINT8_MAX, &mRequest.moveMode);
        AddArgument("Rate", 0, UINT8_MAX, &mRequest.rate);
        AddArgument("OptionMask", 0, UINT8_MAX, &mRequest.optionMask);
        AddArgument("OptionOverride", 0, UINT8_MAX, &mRequest.optionOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000008) command (0x00000001) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000008, 0x00000001, mRequest);
    }

private:
    chip::app::Clusters::LevelControl::Commands::Move::Type mRequest;
};

/*
 * Command MoveToLevel
 */
class LevelControlMoveToLevel : public ClusterCommand
{
public:
    LevelControlMoveToLevel(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-to-level", credsIssuerConfig)
    {
        AddArgument("Level", 0, UINT8_MAX, &mRequest.level);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionMask", 0, UINT8_MAX, &mRequest.optionMask);
        AddArgument("OptionOverride", 0, UINT8_MAX, &mRequest.optionOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000008) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000008, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::LevelControl::Commands::MoveToLevel::Type mRequest;
};

/*
 * Command MoveToLevelWithOnOff
 */
class LevelControlMoveToLevelWithOnOff : public ClusterCommand
{
public:
    LevelControlMoveToLevelWithOnOff(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("move-to-level-with-on-off", credsIssuerConfig)
    {
        AddArgument("Level", 0, UINT8_MAX, &mRequest.level);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000008) command (0x00000004) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000008, 0x00000004, mRequest);
    }

private:
    chip::app::Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Type mRequest;
};

/*
 * Command MoveWithOnOff
 */
class LevelControlMoveWithOnOff : public ClusterCommand
{
public:
    LevelControlMoveWithOnOff(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-with-on-off", credsIssuerConfig)
    {
        AddArgument("MoveMode", 0, UINT8_MAX, &mRequest.moveMode);
        AddArgument("Rate", 0, UINT8_MAX, &mRequest.rate);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000008) command (0x00000005) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000008, 0x00000005, mRequest);
    }

private:
    chip::app::Clusters::LevelControl::Commands::MoveWithOnOff::Type mRequest;
};

/*
 * Command Step
 */
class LevelControlStep : public ClusterCommand
{
public:
    LevelControlStep(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("step", credsIssuerConfig)
    {
        AddArgument("StepMode", 0, UINT8_MAX, &mRequest.stepMode);
        AddArgument("StepSize", 0, UINT8_MAX, &mRequest.stepSize);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("OptionMask", 0, UINT8_MAX, &mRequest.optionMask);
        AddArgument("OptionOverride", 0, UINT8_MAX, &mRequest.optionOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000008) command (0x00000002) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000008, 0x00000002, mRequest);
    }

private:
    chip::app::Clusters::LevelControl::Commands::Step::Type mRequest;
};

/*
 * Command StepWithOnOff
 */
class LevelControlStepWithOnOff : public ClusterCommand
{
public:
    LevelControlStepWithOnOff(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("step-with-on-off", credsIssuerConfig)
    {
        AddArgument("StepMode", 0, UINT8_MAX, &mRequest.stepMode);
        AddArgument("StepSize", 0, UINT8_MAX, &mRequest.stepSize);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000008) command (0x00000006) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000008, 0x00000006, mRequest);
    }

private:
    chip::app::Clusters::LevelControl::Commands::StepWithOnOff::Type mRequest;
};

/*
 * Command Stop
 */
class LevelControlStop : public ClusterCommand
{
public:
    LevelControlStop(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop", credsIssuerConfig)
    {
        AddArgument("OptionMask", 0, UINT8_MAX, &mRequest.optionMask);
        AddArgument("OptionOverride", 0, UINT8_MAX, &mRequest.optionOverride);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000008) command (0x00000003) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000008, 0x00000003, mRequest);
    }

private:
    chip::app::Clusters::LevelControl::Commands::Stop::Type mRequest;
};

/*
 * Command StopWithOnOff
 */
class LevelControlStopWithOnOff : public ClusterCommand
{
public:
    LevelControlStopWithOnOff(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop-with-on-off", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000008) command (0x00000007) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000008, 0x00000007, mRequest);
    }

private:
    chip::app::Clusters::LevelControl::Commands::StopWithOnOff::Type mRequest;
};

class WriteLevelControlOptions : public WriteAttribute
{
public:
    WriteLevelControlOptions(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Options", credsIssuerConfig)
    {
        AddArgument("attr-name", "options");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteLevelControlOptions() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000008, 0x0000000F, mValue);
    }

private:
    uint8_t mValue;
};

class WriteLevelControlOnOffTransitionTime : public WriteAttribute
{
public:
    WriteLevelControlOnOffTransitionTime(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("OnOffTransitionTime", credsIssuerConfig)
    {
        AddArgument("attr-name", "on-off-transition-time");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteLevelControlOnOffTransitionTime() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000008, 0x00000010, mValue);
    }

private:
    uint16_t mValue;
};

class WriteLevelControlOnLevel : public WriteAttribute
{
public:
    WriteLevelControlOnLevel(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("OnLevel", credsIssuerConfig)
    {
        AddArgument("attr-name", "on-level");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteLevelControlOnLevel() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000008, 0x00000011, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint8_t> mValue;
};

class WriteLevelControlOnTransitionTime : public WriteAttribute
{
public:
    WriteLevelControlOnTransitionTime(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("OnTransitionTime", credsIssuerConfig)
    {
        AddArgument("attr-name", "on-transition-time");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteLevelControlOnTransitionTime() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000008, 0x00000012, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint16_t> mValue;
};

class WriteLevelControlOffTransitionTime : public WriteAttribute
{
public:
    WriteLevelControlOffTransitionTime(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("OffTransitionTime", credsIssuerConfig)
    {
        AddArgument("attr-name", "off-transition-time");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteLevelControlOffTransitionTime() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000008, 0x00000013, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint16_t> mValue;
};

class WriteLevelControlDefaultMoveRate : public WriteAttribute
{
public:
    WriteLevelControlDefaultMoveRate(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("DefaultMoveRate", credsIssuerConfig)
    {
        AddArgument("attr-name", "default-move-rate");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteLevelControlDefaultMoveRate() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000008, 0x00000014, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint8_t> mValue;
};

class WriteLevelControlStartUpCurrentLevel : public WriteAttribute
{
public:
    WriteLevelControlStartUpCurrentLevel(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("StartUpCurrentLevel", credsIssuerConfig)
    {
        AddArgument("attr-name", "start-up-current-level");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteLevelControlStartUpCurrentLevel() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000008, 0x00004000, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint8_t> mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster LocalizationConfiguration                                   | 0x002B |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * ActiveLocale                                                      | 0x0001 |
| * SupportedLocales                                                  | 0x0002 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

class WriteLocalizationConfigurationActiveLocale : public WriteAttribute
{
public:
    WriteLocalizationConfigurationActiveLocale(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("ActiveLocale", credsIssuerConfig)
    {
        AddArgument("attr-name", "active-locale");
        AddArgument("attr-value", &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteLocalizationConfigurationActiveLocale() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000002B, 0x00000001, mValue);
    }

private:
    chip::CharSpan mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster LowPower                                                    | 0x0508 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * Sleep                                                             |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command Sleep
 */
class LowPowerSleep : public ClusterCommand
{
public:
    LowPowerSleep(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("sleep", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000508) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000508, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::LowPower::Commands::Sleep::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster MediaInput                                                  | 0x0507 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * HideInputStatusRequest                                            |   0x02 |
| * RenameInputRequest                                                |   0x03 |
| * SelectInputRequest                                                |   0x00 |
| * ShowInputStatusRequest                                            |   0x01 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MediaInputList                                                    | 0x0000 |
| * CurrentMediaInput                                                 | 0x0001 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command HideInputStatusRequest
 */
class MediaInputHideInputStatusRequest : public ClusterCommand
{
public:
    MediaInputHideInputStatusRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("hide-input-status-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000507) command (0x00000002) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000507, 0x00000002, mRequest);
    }

private:
    chip::app::Clusters::MediaInput::Commands::HideInputStatusRequest::Type mRequest;
};

/*
 * Command RenameInputRequest
 */
class MediaInputRenameInputRequest : public ClusterCommand
{
public:
    MediaInputRenameInputRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("rename-input-request", credsIssuerConfig)
    {
        AddArgument("Index", 0, UINT8_MAX, &mRequest.index);
        AddArgument("Name", &mRequest.name);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000507) command (0x00000003) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000507, 0x00000003, mRequest);
    }

private:
    chip::app::Clusters::MediaInput::Commands::RenameInputRequest::Type mRequest;
};

/*
 * Command SelectInputRequest
 */
class MediaInputSelectInputRequest : public ClusterCommand
{
public:
    MediaInputSelectInputRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("select-input-request", credsIssuerConfig)
    {
        AddArgument("Index", 0, UINT8_MAX, &mRequest.index);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000507) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000507, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::MediaInput::Commands::SelectInputRequest::Type mRequest;
};

/*
 * Command ShowInputStatusRequest
 */
class MediaInputShowInputStatusRequest : public ClusterCommand
{
public:
    MediaInputShowInputStatusRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("show-input-status-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000507) command (0x00000001) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000507, 0x00000001, mRequest);
    }

private:
    chip::app::Clusters::MediaInput::Commands::ShowInputStatusRequest::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster MediaPlayback                                               | 0x0506 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * FastForwardRequest                                                |   0x07 |
| * NextRequest                                                       |   0x05 |
| * PauseRequest                                                      |   0x01 |
| * PlayRequest                                                       |   0x00 |
| * PreviousRequest                                                   |   0x04 |
| * RewindRequest                                                     |   0x06 |
| * SeekRequest                                                       |   0x0B |
| * SkipBackwardRequest                                               |   0x09 |
| * SkipForwardRequest                                                |   0x08 |
| * StartOverRequest                                                  |   0x03 |
| * StopRequest                                                       |   0x02 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * PlaybackState                                                     | 0x0000 |
| * StartTime                                                         | 0x0001 |
| * Duration                                                          | 0x0002 |
| * Position                                                          | 0x0003 |
| * PlaybackSpeed                                                     | 0x0004 |
| * SeekRangeEnd                                                      | 0x0005 |
| * SeekRangeStart                                                    | 0x0006 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command FastForwardRequest
 */
class MediaPlaybackFastForwardRequest : public ClusterCommand
{
public:
    MediaPlaybackFastForwardRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("fast-forward-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000007) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000007, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::FastForwardRequest::Type mRequest;
};

/*
 * Command NextRequest
 */
class MediaPlaybackNextRequest : public ClusterCommand
{
public:
    MediaPlaybackNextRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("next-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000005) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000005, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::NextRequest::Type mRequest;
};

/*
 * Command PauseRequest
 */
class MediaPlaybackPauseRequest : public ClusterCommand
{
public:
    MediaPlaybackPauseRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("pause-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000001) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000001, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::PauseRequest::Type mRequest;
};

/*
 * Command PlayRequest
 */
class MediaPlaybackPlayRequest : public ClusterCommand
{
public:
    MediaPlaybackPlayRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("play-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::PlayRequest::Type mRequest;
};

/*
 * Command PreviousRequest
 */
class MediaPlaybackPreviousRequest : public ClusterCommand
{
public:
    MediaPlaybackPreviousRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("previous-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000004) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000004, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::PreviousRequest::Type mRequest;
};

/*
 * Command RewindRequest
 */
class MediaPlaybackRewindRequest : public ClusterCommand
{
public:
    MediaPlaybackRewindRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("rewind-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000006) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000006, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::RewindRequest::Type mRequest;
};

/*
 * Command SeekRequest
 */
class MediaPlaybackSeekRequest : public ClusterCommand
{
public:
    MediaPlaybackSeekRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("seek-request", credsIssuerConfig)
    {
        AddArgument("Position", 0, UINT64_MAX, &mRequest.position);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x0000000B) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x0000000B, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::SeekRequest::Type mRequest;
};

/*
 * Command SkipBackwardRequest
 */
class MediaPlaybackSkipBackwardRequest : public ClusterCommand
{
public:
    MediaPlaybackSkipBackwardRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("skip-backward-request", credsIssuerConfig)
    {
        AddArgument("DeltaPositionMilliseconds", 0, UINT64_MAX, &mRequest.deltaPositionMilliseconds);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000009) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000009, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::SkipBackwardRequest::Type mRequest;
};

/*
 * Command SkipForwardRequest
 */
class MediaPlaybackSkipForwardRequest : public ClusterCommand
{
public:
    MediaPlaybackSkipForwardRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("skip-forward-request", credsIssuerConfig)
    {
        AddArgument("DeltaPositionMilliseconds", 0, UINT64_MAX, &mRequest.deltaPositionMilliseconds);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000008) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000008, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::SkipForwardRequest::Type mRequest;
};

/*
 * Command StartOverRequest
 */
class MediaPlaybackStartOverRequest : public ClusterCommand
{
public:
    MediaPlaybackStartOverRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("start-over-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000003) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000003, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::StartOverRequest::Type mRequest;
};

/*
 * Command StopRequest
 */
class MediaPlaybackStopRequest : public ClusterCommand
{
public:
    MediaPlaybackStopRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000002) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000002, mRequest);
    }

private:
    chip::app::Clusters::MediaPlayback::Commands::StopRequest::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster ModeSelect                                                  | 0x0050 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ChangeToMode                                                      |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * CurrentMode                                                       | 0x0000 |
| * SupportedModes                                                    | 0x0001 |
| * OnMode                                                            | 0x0002 |
| * StartUpMode                                                       | 0x0003 |
| * Description                                                       | 0x0004 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ChangeToMode
 */
class ModeSelectChangeToMode : public ClusterCommand
{
public:
    ModeSelectChangeToMode(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("change-to-mode", credsIssuerConfig)
    {
        AddArgument("NewMode", 0, UINT8_MAX, &mRequest.newMode);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000050) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000050, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::ModeSelect::Commands::ChangeToMode::Type mRequest;
};

class WriteModeSelectOnMode : public WriteAttribute
{
public:
    WriteModeSelectOnMode(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("OnMode", credsIssuerConfig)
    {
        AddArgument("attr-name", "on-mode");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteModeSelectOnMode() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000050, 0x00000002, mValue);
    }

private:
    uint8_t mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster NetworkCommissioning                                        | 0x0031 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * AddOrUpdateThreadNetwork                                          |   0x03 |
| * AddOrUpdateWiFiNetwork                                            |   0x02 |
| * ConnectNetwork                                                    |   0x06 |
| * RemoveNetwork                                                     |   0x04 |
| * ReorderNetwork                                                    |   0x08 |
| * ScanNetworks                                                      |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MaxNetworks                                                       | 0x0000 |
| * Networks                                                          | 0x0001 |
| * ScanMaxTimeSeconds                                                | 0x0002 |
| * ConnectMaxTimeSeconds                                             | 0x0003 |
| * InterfaceEnabled                                                  | 0x0004 |
| * LastNetworkingStatus                                              | 0x0005 |
| * LastNetworkID                                                     | 0x0006 |
| * LastConnectErrorValue                                             | 0x0007 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command AddOrUpdateThreadNetwork
 */
class NetworkCommissioningAddOrUpdateThreadNetwork : public ClusterCommand
{
public:
    NetworkCommissioningAddOrUpdateThreadNetwork(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("add-or-update-thread-network", credsIssuerConfig)
    {
        AddArgument("OperationalDataset", &mRequest.operationalDataset);
        AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000031) command (0x00000003) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000031, 0x00000003, mRequest);
    }

private:
    chip::app::Clusters::NetworkCommissioning::Commands::AddOrUpdateThreadNetwork::Type mRequest;
};

/*
 * Command AddOrUpdateWiFiNetwork
 */
class NetworkCommissioningAddOrUpdateWiFiNetwork : public ClusterCommand
{
public:
    NetworkCommissioningAddOrUpdateWiFiNetwork(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("add-or-update-wi-fi-network", credsIssuerConfig)
    {
        AddArgument("Ssid", &mRequest.ssid);
        AddArgument("Credentials", &mRequest.credentials);
        AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000031) command (0x00000002) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000031, 0x00000002, mRequest);
    }

private:
    chip::app::Clusters::NetworkCommissioning::Commands::AddOrUpdateWiFiNetwork::Type mRequest;
};

/*
 * Command ConnectNetwork
 */
class NetworkCommissioningConnectNetwork : public ClusterCommand
{
public:
    NetworkCommissioningConnectNetwork(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("connect-network", credsIssuerConfig)
    {
        AddArgument("NetworkID", &mRequest.networkID);
        AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000031) command (0x00000006) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000031, 0x00000006, mRequest);
    }

private:
    chip::app::Clusters::NetworkCommissioning::Commands::ConnectNetwork::Type mRequest;
};

/*
 * Command RemoveNetwork
 */
class NetworkCommissioningRemoveNetwork : public ClusterCommand
{
public:
    NetworkCommissioningRemoveNetwork(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("remove-network", credsIssuerConfig)
    {
        AddArgument("NetworkID", &mRequest.networkID);
        AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000031) command (0x00000004) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000031, 0x00000004, mRequest);
    }

private:
    chip::app::Clusters::NetworkCommissioning::Commands::RemoveNetwork::Type mRequest;
};

/*
 * Command ReorderNetwork
 */
class NetworkCommissioningReorderNetwork : public ClusterCommand
{
public:
    NetworkCommissioningReorderNetwork(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("reorder-network", credsIssuerConfig)
    {
        AddArgument("NetworkID", &mRequest.networkID);
        AddArgument("NetworkIndex", 0, UINT8_MAX, &mRequest.networkIndex);
        AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000031) command (0x00000008) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000031, 0x00000008, mRequest);
    }

private:
    chip::app::Clusters::NetworkCommissioning::Commands::ReorderNetwork::Type mRequest;
};

/*
 * Command ScanNetworks
 */
class NetworkCommissioningScanNetworks : public ClusterCommand
{
public:
    NetworkCommissioningScanNetworks(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("scan-networks", credsIssuerConfig)
    {
        AddArgument("Ssid", &mRequest.ssid);
        AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000031) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000031, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::NetworkCommissioning::Commands::ScanNetworks::Type mRequest;
};

class WriteNetworkCommissioningInterfaceEnabled : public WriteAttribute
{
public:
    WriteNetworkCommissioningInterfaceEnabled(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("InterfaceEnabled", credsIssuerConfig)
    {
        AddArgument("attr-name", "interface-enabled");
        AddArgument("attr-value", 0, 1, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteNetworkCommissioningInterfaceEnabled() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000031, 0x00000004, mValue);
    }

private:
    bool mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster OtaSoftwareUpdateProvider                                   | 0x0029 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ApplyUpdateRequest                                                |   0x02 |
| * NotifyUpdateApplied                                               |   0x04 |
| * QueryImage                                                        |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ApplyUpdateRequest
 */
class OtaSoftwareUpdateProviderApplyUpdateRequest : public ClusterCommand
{
public:
    OtaSoftwareUpdateProviderApplyUpdateRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("apply-update-request", credsIssuerConfig)
    {
        AddArgument("UpdateToken", &mRequest.updateToken);
        AddArgument("NewVersion", 0, UINT32_MAX, &mRequest.newVersion);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000029) command (0x00000002) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000029, 0x00000002, mRequest);
    }

private:
    chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::ApplyUpdateRequest::Type mRequest;
};

/*
 * Command NotifyUpdateApplied
 */
class OtaSoftwareUpdateProviderNotifyUpdateApplied : public ClusterCommand
{
public:
    OtaSoftwareUpdateProviderNotifyUpdateApplied(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("notify-update-applied", credsIssuerConfig)
    {
        AddArgument("UpdateToken", &mRequest.updateToken);
        AddArgument("SoftwareVersion", 0, UINT32_MAX, &mRequest.softwareVersion);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000029) command (0x00000004) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000029, 0x00000004, mRequest);
    }

private:
    chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::NotifyUpdateApplied::Type mRequest;
};

/*
 * Command QueryImage
 */
class OtaSoftwareUpdateProviderQueryImage : public ClusterCommand
{
public:
    OtaSoftwareUpdateProviderQueryImage(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("query-image", credsIssuerConfig), mComplex_ProtocolsSupported(&mRequest.protocolsSupported)
    {
        AddArgument("VendorId", 0, UINT16_MAX, &mRequest.vendorId);
        AddArgument("ProductId", 0, UINT16_MAX, &mRequest.productId);
        AddArgument("SoftwareVersion", 0, UINT32_MAX, &mRequest.softwareVersion);
        AddArgument("ProtocolsSupported", &mComplex_ProtocolsSupported);
        AddArgument("HardwareVersion", 0, UINT16_MAX, &mRequest.hardwareVersion);
        AddArgument("Location", &mRequest.location);
        AddArgument("RequestorCanConsent", 0, 1, &mRequest.requestorCanConsent);
        AddArgument("MetadataForProvider", &mRequest.metadataForProvider);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000029) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000029, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::QueryImage::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::OtaSoftwareUpdateProvider::OTADownloadProtocol>>
        mComplex_ProtocolsSupported;
};

/*----------------------------------------------------------------------------*\
| Cluster OtaSoftwareUpdateRequestor                                  | 0x002A |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * AnnounceOtaProvider                                               |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * DefaultOtaProviders                                               | 0x0000 |
| * UpdatePossible                                                    | 0x0001 |
| * UpdateState                                                       | 0x0002 |
| * UpdateStateProgress                                               | 0x0003 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * StateTransition                                                   | 0x0000 |
| * VersionApplied                                                    | 0x0001 |
| * DownloadError                                                     | 0x0002 |
\*----------------------------------------------------------------------------*/

/*
 * Command AnnounceOtaProvider
 */
class OtaSoftwareUpdateRequestorAnnounceOtaProvider : public ClusterCommand
{
public:
    OtaSoftwareUpdateRequestorAnnounceOtaProvider(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("announce-ota-provider", credsIssuerConfig)
    {
        AddArgument("ProviderNodeId", 0, UINT64_MAX, &mRequest.providerNodeId);
        AddArgument("VendorId", 0, UINT16_MAX, &mRequest.vendorId);
        AddArgument("AnnouncementReason", 0, UINT8_MAX, &mRequest.announcementReason);
        AddArgument("MetadataForNode", &mRequest.metadataForNode);
        AddArgument("Endpoint", 0, UINT16_MAX, &mRequest.endpoint);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000002A) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000002A, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::OtaSoftwareUpdateRequestor::Commands::AnnounceOtaProvider::Type mRequest;
};

class WriteOtaSoftwareUpdateRequestorDefaultOtaProviders : public WriteAttribute
{
public:
    WriteOtaSoftwareUpdateRequestorDefaultOtaProviders(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("DefaultOtaProviders", credsIssuerConfig), mComplex(&mValue)
    {
        AddArgument("attr-name", "default-ota-providers");
        AddArgument("attr-value", &mComplex);
        WriteAttribute::AddArguments();
    }

    ~WriteOtaSoftwareUpdateRequestorDefaultOtaProviders() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000002A, 0x00000000, mValue);
    }

private:
    chip::app::DataModel::List<const chip::app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::Type> mValue;
    TypedComplexArgument<
        chip::app::DataModel::List<const chip::app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::Type>>
        mComplex;
};

/*----------------------------------------------------------------------------*\
| Cluster OccupancySensing                                            | 0x0406 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Occupancy                                                         | 0x0000 |
| * OccupancySensorType                                               | 0x0001 |
| * OccupancySensorTypeBitmap                                         | 0x0002 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster OnOff                                                       | 0x0006 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * Off                                                               |   0x00 |
| * OffWithEffect                                                     |   0x40 |
| * On                                                                |   0x01 |
| * OnWithRecallGlobalScene                                           |   0x41 |
| * OnWithTimedOff                                                    |   0x42 |
| * Toggle                                                            |   0x02 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * OnOff                                                             | 0x0000 |
| * GlobalSceneControl                                                | 0x4000 |
| * OnTime                                                            | 0x4001 |
| * OffWaitTime                                                       | 0x4002 |
| * StartUpOnOff                                                      | 0x4003 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command Off
 */
class OnOffOff : public ClusterCommand
{
public:
    OnOffOff(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("off", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000006) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000006, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::OnOff::Commands::Off::Type mRequest;
};

/*
 * Command OffWithEffect
 */
class OnOffOffWithEffect : public ClusterCommand
{
public:
    OnOffOffWithEffect(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("off-with-effect", credsIssuerConfig)
    {
        AddArgument("EffectId", 0, UINT8_MAX, &mRequest.effectId);
        AddArgument("EffectVariant", 0, UINT8_MAX, &mRequest.effectVariant);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000006) command (0x00000040) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000006, 0x00000040, mRequest);
    }

private:
    chip::app::Clusters::OnOff::Commands::OffWithEffect::Type mRequest;
};

/*
 * Command On
 */
class OnOffOn : public ClusterCommand
{
public:
    OnOffOn(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("on", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000006) command (0x00000001) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000006, 0x00000001, mRequest);
    }

private:
    chip::app::Clusters::OnOff::Commands::On::Type mRequest;
};

/*
 * Command OnWithRecallGlobalScene
 */
class OnOffOnWithRecallGlobalScene : public ClusterCommand
{
public:
    OnOffOnWithRecallGlobalScene(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("on-with-recall-global-scene", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000006) command (0x00000041) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000006, 0x00000041, mRequest);
    }

private:
    chip::app::Clusters::OnOff::Commands::OnWithRecallGlobalScene::Type mRequest;
};

/*
 * Command OnWithTimedOff
 */
class OnOffOnWithTimedOff : public ClusterCommand
{
public:
    OnOffOnWithTimedOff(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("on-with-timed-off", credsIssuerConfig)
    {
        AddArgument("OnOffControl", 0, UINT8_MAX, &mRequest.onOffControl);
        AddArgument("OnTime", 0, UINT16_MAX, &mRequest.onTime);
        AddArgument("OffWaitTime", 0, UINT16_MAX, &mRequest.offWaitTime);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000006) command (0x00000042) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000006, 0x00000042, mRequest);
    }

private:
    chip::app::Clusters::OnOff::Commands::OnWithTimedOff::Type mRequest;
};

/*
 * Command Toggle
 */
class OnOffToggle : public ClusterCommand
{
public:
    OnOffToggle(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("toggle", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000006) command (0x00000002) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000006, 0x00000002, mRequest);
    }

private:
    chip::app::Clusters::OnOff::Commands::Toggle::Type mRequest;
};

class WriteOnOffOnTime : public WriteAttribute
{
public:
    WriteOnOffOnTime(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("OnTime", credsIssuerConfig)
    {
        AddArgument("attr-name", "on-time");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteOnOffOnTime() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000006, 0x00004001, mValue);
    }

private:
    uint16_t mValue;
};

class WriteOnOffOffWaitTime : public WriteAttribute
{
public:
    WriteOnOffOffWaitTime(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("OffWaitTime", credsIssuerConfig)
    {
        AddArgument("attr-name", "off-wait-time");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteOnOffOffWaitTime() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000006, 0x00004002, mValue);
    }

private:
    uint16_t mValue;
};

class WriteOnOffStartUpOnOff : public WriteAttribute
{
public:
    WriteOnOffStartUpOnOff(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("StartUpOnOff", credsIssuerConfig)
    {
        AddArgument("attr-name", "start-up-on-off");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteOnOffStartUpOnOff() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000006, 0x00004003, mValue);
    }

private:
    uint8_t mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster OnOffSwitchConfiguration                                    | 0x0007 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * SwitchType                                                        | 0x0000 |
| * SwitchActions                                                     | 0x0010 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

class WriteOnOffSwitchConfigurationSwitchActions : public WriteAttribute
{
public:
    WriteOnOffSwitchConfigurationSwitchActions(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("SwitchActions", credsIssuerConfig)
    {
        AddArgument("attr-name", "switch-actions");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteOnOffSwitchConfigurationSwitchActions() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000007, 0x00000010, mValue);
    }

private:
    uint8_t mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster OperationalCredentials                                      | 0x003E |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * AddNOC                                                            |   0x06 |
| * AddTrustedRootCertificate                                         |   0x0B |
| * AttestationRequest                                                |   0x00 |
| * CSRRequest                                                        |   0x04 |
| * CertificateChainRequest                                           |   0x02 |
| * RemoveFabric                                                      |   0x0A |
| * RemoveTrustedRootCertificate                                      |   0x0C |
| * UpdateFabricLabel                                                 |   0x09 |
| * UpdateNOC                                                         |   0x07 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * NOCs                                                              | 0x0000 |
| * FabricsList                                                       | 0x0001 |
| * SupportedFabrics                                                  | 0x0002 |
| * CommissionedFabrics                                               | 0x0003 |
| * TrustedRootCertificates                                           | 0x0004 |
| * CurrentFabricIndex                                                | 0x0005 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command AddNOC
 */
class OperationalCredentialsAddNOC : public ClusterCommand
{
public:
    OperationalCredentialsAddNOC(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("add-noc", credsIssuerConfig)
    {
        AddArgument("NOCValue", &mRequest.NOCValue);
        AddArgument("ICACValue", &mRequest.ICACValue);
        AddArgument("IPKValue", &mRequest.IPKValue);
        AddArgument("CaseAdminNode", 0, UINT64_MAX, &mRequest.caseAdminNode);
        AddArgument("AdminVendorId", 0, UINT16_MAX, &mRequest.adminVendorId);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000003E) command (0x00000006) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000003E, 0x00000006, mRequest);
    }

private:
    chip::app::Clusters::OperationalCredentials::Commands::AddNOC::Type mRequest;
};

/*
 * Command AddTrustedRootCertificate
 */
class OperationalCredentialsAddTrustedRootCertificate : public ClusterCommand
{
public:
    OperationalCredentialsAddTrustedRootCertificate(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("add-trusted-root-certificate", credsIssuerConfig)
    {
        AddArgument("RootCertificate", &mRequest.rootCertificate);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000003E) command (0x0000000B) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000003E, 0x0000000B, mRequest);
    }

private:
    chip::app::Clusters::OperationalCredentials::Commands::AddTrustedRootCertificate::Type mRequest;
};

/*
 * Command AttestationRequest
 */
class OperationalCredentialsAttestationRequest : public ClusterCommand
{
public:
    OperationalCredentialsAttestationRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("attestation-request", credsIssuerConfig)
    {
        AddArgument("AttestationNonce", &mRequest.attestationNonce);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000003E) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000003E, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::OperationalCredentials::Commands::AttestationRequest::Type mRequest;
};

/*
 * Command CSRRequest
 */
class OperationalCredentialsCSRRequest : public ClusterCommand
{
public:
    OperationalCredentialsCSRRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("csrrequest", credsIssuerConfig)
    {
        AddArgument("CSRNonce", &mRequest.CSRNonce);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000003E) command (0x00000004) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000003E, 0x00000004, mRequest);
    }

private:
    chip::app::Clusters::OperationalCredentials::Commands::CSRRequest::Type mRequest;
};

/*
 * Command CertificateChainRequest
 */
class OperationalCredentialsCertificateChainRequest : public ClusterCommand
{
public:
    OperationalCredentialsCertificateChainRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("certificate-chain-request", credsIssuerConfig)
    {
        AddArgument("CertificateType", 0, UINT8_MAX, &mRequest.certificateType);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000003E) command (0x00000002) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000003E, 0x00000002, mRequest);
    }

private:
    chip::app::Clusters::OperationalCredentials::Commands::CertificateChainRequest::Type mRequest;
};

/*
 * Command RemoveFabric
 */
class OperationalCredentialsRemoveFabric : public ClusterCommand
{
public:
    OperationalCredentialsRemoveFabric(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("remove-fabric", credsIssuerConfig)
    {
        AddArgument("FabricIndex", 0, UINT8_MAX, &mRequest.fabricIndex);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000003E) command (0x0000000A) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000003E, 0x0000000A, mRequest);
    }

private:
    chip::app::Clusters::OperationalCredentials::Commands::RemoveFabric::Type mRequest;
};

/*
 * Command RemoveTrustedRootCertificate
 */
class OperationalCredentialsRemoveTrustedRootCertificate : public ClusterCommand
{
public:
    OperationalCredentialsRemoveTrustedRootCertificate(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("remove-trusted-root-certificate", credsIssuerConfig)
    {
        AddArgument("TrustedRootIdentifier", &mRequest.trustedRootIdentifier);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000003E) command (0x0000000C) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000003E, 0x0000000C, mRequest);
    }

private:
    chip::app::Clusters::OperationalCredentials::Commands::RemoveTrustedRootCertificate::Type mRequest;
};

/*
 * Command UpdateFabricLabel
 */
class OperationalCredentialsUpdateFabricLabel : public ClusterCommand
{
public:
    OperationalCredentialsUpdateFabricLabel(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("update-fabric-label", credsIssuerConfig)
    {
        AddArgument("Label", &mRequest.label);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000003E) command (0x00000009) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000003E, 0x00000009, mRequest);
    }

private:
    chip::app::Clusters::OperationalCredentials::Commands::UpdateFabricLabel::Type mRequest;
};

/*
 * Command UpdateNOC
 */
class OperationalCredentialsUpdateNOC : public ClusterCommand
{
public:
    OperationalCredentialsUpdateNOC(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("update-noc", credsIssuerConfig)
    {
        AddArgument("NOCValue", &mRequest.NOCValue);
        AddArgument("ICACValue", &mRequest.ICACValue);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000003E) command (0x00000007) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000003E, 0x00000007, mRequest);
    }

private:
    chip::app::Clusters::OperationalCredentials::Commands::UpdateNOC::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster PowerSource                                                 | 0x002F |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Status                                                            | 0x0000 |
| * Order                                                             | 0x0001 |
| * Description                                                       | 0x0002 |
| * BatteryVoltage                                                    | 0x000B |
| * BatteryPercentRemaining                                           | 0x000C |
| * BatteryTimeRemaining                                              | 0x000D |
| * BatteryChargeLevel                                                | 0x000E |
| * ActiveBatteryFaults                                               | 0x0012 |
| * BatteryChargeState                                                | 0x001A |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster PowerSourceConfiguration                                    | 0x002E |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Sources                                                           | 0x0000 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster PressureMeasurement                                         | 0x0403 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster PumpConfigurationAndControl                                 | 0x0200 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MaxPressure                                                       | 0x0000 |
| * MaxSpeed                                                          | 0x0001 |
| * MaxFlow                                                           | 0x0002 |
| * MinConstPressure                                                  | 0x0003 |
| * MaxConstPressure                                                  | 0x0004 |
| * MinCompPressure                                                   | 0x0005 |
| * MaxCompPressure                                                   | 0x0006 |
| * MinConstSpeed                                                     | 0x0007 |
| * MaxConstSpeed                                                     | 0x0008 |
| * MinConstFlow                                                      | 0x0009 |
| * MaxConstFlow                                                      | 0x000A |
| * MinConstTemp                                                      | 0x000B |
| * MaxConstTemp                                                      | 0x000C |
| * PumpStatus                                                        | 0x0010 |
| * EffectiveOperationMode                                            | 0x0011 |
| * EffectiveControlMode                                              | 0x0012 |
| * Capacity                                                          | 0x0013 |
| * Speed                                                             | 0x0014 |
| * LifetimeRunningHours                                              | 0x0015 |
| * Power                                                             | 0x0016 |
| * LifetimeEnergyConsumed                                            | 0x0017 |
| * OperationMode                                                     | 0x0020 |
| * ControlMode                                                       | 0x0021 |
| * AlarmMask                                                         | 0x0022 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * SupplyVoltageLow                                                  | 0x0000 |
| * SupplyVoltageHigh                                                 | 0x0001 |
| * PowerMissingPhase                                                 | 0x0002 |
| * SystemPressureLow                                                 | 0x0003 |
| * SystemPressureHigh                                                | 0x0004 |
| * DryRunning                                                        | 0x0005 |
| * MotorTemperatureHigh                                              | 0x0006 |
| * PumpMotorFatalFailure                                             | 0x0007 |
| * ElectronicTemperatureHigh                                         | 0x0008 |
| * PumpBlocked                                                       | 0x0009 |
| * SensorFailure                                                     | 0x000A |
| * ElectronicNonFatalFailure                                         | 0x000B |
| * ElectronicFatalFailure                                            | 0x000C |
| * GeneralFault                                                      | 0x000D |
| * Leakage                                                           | 0x000E |
| * AirDetection                                                      | 0x000F |
| * TurbineOperation                                                  | 0x0010 |
\*----------------------------------------------------------------------------*/

class WritePumpConfigurationAndControlLifetimeRunningHours : public WriteAttribute
{
public:
    WritePumpConfigurationAndControlLifetimeRunningHours(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("LifetimeRunningHours", credsIssuerConfig)
    {
        AddArgument("attr-name", "lifetime-running-hours");
        AddArgument("attr-value", 0, UINT32_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WritePumpConfigurationAndControlLifetimeRunningHours() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000200, 0x00000015, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint32_t> mValue;
};

class WritePumpConfigurationAndControlLifetimeEnergyConsumed : public WriteAttribute
{
public:
    WritePumpConfigurationAndControlLifetimeEnergyConsumed(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("LifetimeEnergyConsumed", credsIssuerConfig)
    {
        AddArgument("attr-name", "lifetime-energy-consumed");
        AddArgument("attr-value", 0, UINT32_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WritePumpConfigurationAndControlLifetimeEnergyConsumed() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000200, 0x00000017, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint32_t> mValue;
};

class WritePumpConfigurationAndControlOperationMode : public WriteAttribute
{
public:
    WritePumpConfigurationAndControlOperationMode(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("OperationMode", credsIssuerConfig)
    {
        AddArgument("attr-name", "operation-mode");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WritePumpConfigurationAndControlOperationMode() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000200, 0x00000020, mValue);
    }

private:
    uint8_t mValue;
};

class WritePumpConfigurationAndControlControlMode : public WriteAttribute
{
public:
    WritePumpConfigurationAndControlControlMode(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("ControlMode", credsIssuerConfig)
    {
        AddArgument("attr-name", "control-mode");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WritePumpConfigurationAndControlControlMode() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000200, 0x00000021, mValue);
    }

private:
    uint8_t mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster RelativeHumidityMeasurement                                 | 0x0405 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * Tolerance                                                         | 0x0003 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster Scenes                                                      | 0x0005 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * AddScene                                                          |   0x00 |
| * GetSceneMembership                                                |   0x06 |
| * RecallScene                                                       |   0x05 |
| * RemoveAllScenes                                                   |   0x03 |
| * RemoveScene                                                       |   0x02 |
| * StoreScene                                                        |   0x04 |
| * ViewScene                                                         |   0x01 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * SceneCount                                                        | 0x0000 |
| * CurrentScene                                                      | 0x0001 |
| * CurrentGroup                                                      | 0x0002 |
| * SceneValid                                                        | 0x0003 |
| * NameSupport                                                       | 0x0004 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command AddScene
 */
class ScenesAddScene : public ClusterCommand
{
public:
    ScenesAddScene(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("add-scene", credsIssuerConfig), mComplex_ExtensionFieldSets(&mRequest.extensionFieldSets)
    {
        AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
        AddArgument("SceneId", 0, UINT8_MAX, &mRequest.sceneId);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        AddArgument("SceneName", &mRequest.sceneName);
        AddArgument("ExtensionFieldSets", &mComplex_ExtensionFieldSets);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000005) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000005, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::Scenes::Commands::AddScene::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::Scenes::Structs::SceneExtensionFieldSet::Type>>
        mComplex_ExtensionFieldSets;
};

/*
 * Command GetSceneMembership
 */
class ScenesGetSceneMembership : public ClusterCommand
{
public:
    ScenesGetSceneMembership(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("get-scene-membership", credsIssuerConfig)
    {
        AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000005) command (0x00000006) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000005, 0x00000006, mRequest);
    }

private:
    chip::app::Clusters::Scenes::Commands::GetSceneMembership::Type mRequest;
};

/*
 * Command RecallScene
 */
class ScenesRecallScene : public ClusterCommand
{
public:
    ScenesRecallScene(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("recall-scene", credsIssuerConfig)
    {
        AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
        AddArgument("SceneId", 0, UINT8_MAX, &mRequest.sceneId);
        AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000005) command (0x00000005) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000005, 0x00000005, mRequest);
    }

private:
    chip::app::Clusters::Scenes::Commands::RecallScene::Type mRequest;
};

/*
 * Command RemoveAllScenes
 */
class ScenesRemoveAllScenes : public ClusterCommand
{
public:
    ScenesRemoveAllScenes(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("remove-all-scenes", credsIssuerConfig)
    {
        AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000005) command (0x00000003) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000005, 0x00000003, mRequest);
    }

private:
    chip::app::Clusters::Scenes::Commands::RemoveAllScenes::Type mRequest;
};

/*
 * Command RemoveScene
 */
class ScenesRemoveScene : public ClusterCommand
{
public:
    ScenesRemoveScene(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("remove-scene", credsIssuerConfig)
    {
        AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
        AddArgument("SceneId", 0, UINT8_MAX, &mRequest.sceneId);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000005) command (0x00000002) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000005, 0x00000002, mRequest);
    }

private:
    chip::app::Clusters::Scenes::Commands::RemoveScene::Type mRequest;
};

/*
 * Command StoreScene
 */
class ScenesStoreScene : public ClusterCommand
{
public:
    ScenesStoreScene(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("store-scene", credsIssuerConfig)
    {
        AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
        AddArgument("SceneId", 0, UINT8_MAX, &mRequest.sceneId);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000005) command (0x00000004) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000005, 0x00000004, mRequest);
    }

private:
    chip::app::Clusters::Scenes::Commands::StoreScene::Type mRequest;
};

/*
 * Command ViewScene
 */
class ScenesViewScene : public ClusterCommand
{
public:
    ScenesViewScene(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("view-scene", credsIssuerConfig)
    {
        AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
        AddArgument("SceneId", 0, UINT8_MAX, &mRequest.sceneId);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000005) command (0x00000001) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000005, 0x00000001, mRequest);
    }

private:
    chip::app::Clusters::Scenes::Commands::ViewScene::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster SoftwareDiagnostics                                         | 0x0034 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ResetWatermarks                                                   |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * ThreadMetrics                                                     | 0x0000 |
| * CurrentHeapFree                                                   | 0x0001 |
| * CurrentHeapUsed                                                   | 0x0002 |
| * CurrentHeapHighWatermark                                          | 0x0003 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * SoftwareFault                                                     | 0x0000 |
\*----------------------------------------------------------------------------*/

/*
 * Command ResetWatermarks
 */
class SoftwareDiagnosticsResetWatermarks : public ClusterCommand
{
public:
    SoftwareDiagnosticsResetWatermarks(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("reset-watermarks", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000034) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000034, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::SoftwareDiagnostics::Commands::ResetWatermarks::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster Switch                                                      | 0x003B |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * NumberOfPositions                                                 | 0x0000 |
| * CurrentPosition                                                   | 0x0001 |
| * MultiPressMax                                                     | 0x0002 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * SwitchLatched                                                     | 0x0000 |
| * InitialPress                                                      | 0x0001 |
| * LongPress                                                         | 0x0002 |
| * ShortRelease                                                      | 0x0003 |
| * LongRelease                                                       | 0x0004 |
| * MultiPressOngoing                                                 | 0x0005 |
| * MultiPressComplete                                                | 0x0006 |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster TargetNavigator                                             | 0x0505 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * NavigateTargetRequest                                             |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * TargetNavigatorList                                               | 0x0000 |
| * CurrentNavigatorTarget                                            | 0x0001 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command NavigateTargetRequest
 */
class TargetNavigatorNavigateTargetRequest : public ClusterCommand
{
public:
    TargetNavigatorNavigateTargetRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("navigate-target-request", credsIssuerConfig)
    {
        AddArgument("Target", 0, UINT8_MAX, &mRequest.target);
        AddArgument("Data", &mRequest.data);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000505) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000505, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::TargetNavigator::Commands::NavigateTargetRequest::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster TemperatureMeasurement                                      | 0x0402 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * MeasuredValue                                                     | 0x0000 |
| * MinMeasuredValue                                                  | 0x0001 |
| * MaxMeasuredValue                                                  | 0x0002 |
| * Tolerance                                                         | 0x0003 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster TestCluster                                                 | 0x050F |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * SimpleStructEchoRequest                                           |   0x11 |
| * Test                                                              |   0x00 |
| * TestAddArguments                                                  |   0x04 |
| * TestEmitTestEventRequest                                          |   0x14 |
| * TestEnumsRequest                                                  |   0x0E |
| * TestListInt8UArgumentRequest                                      |   0x0A |
| * TestListInt8UReverseRequest                                       |   0x0D |
| * TestListNestedStructListArgumentRequest                           |   0x0C |
| * TestListStructArgumentRequest                                     |   0x09 |
| * TestNestedStructArgumentRequest                                   |   0x08 |
| * TestNestedStructListArgumentRequest                               |   0x0B |
| * TestNotHandled                                                    |   0x01 |
| * TestNullableOptionalRequest                                       |   0x0F |
| * TestSimpleOptionalArgumentRequest                                 |   0x13 |
| * TestSpecific                                                      |   0x02 |
| * TestStructArgumentRequest                                         |   0x07 |
| * TestUnknownCommand                                                |   0x03 |
| * TimedInvokeRequest                                                |   0x12 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Boolean                                                           | 0x0000 |
| * Bitmap8                                                           | 0x0001 |
| * Bitmap16                                                          | 0x0002 |
| * Bitmap32                                                          | 0x0003 |
| * Bitmap64                                                          | 0x0004 |
| * Int8u                                                             | 0x0005 |
| * Int16u                                                            | 0x0006 |
| * Int24u                                                            | 0x0007 |
| * Int32u                                                            | 0x0008 |
| * Int40u                                                            | 0x0009 |
| * Int48u                                                            | 0x000A |
| * Int56u                                                            | 0x000B |
| * Int64u                                                            | 0x000C |
| * Int8s                                                             | 0x000D |
| * Int16s                                                            | 0x000E |
| * Int24s                                                            | 0x000F |
| * Int32s                                                            | 0x0010 |
| * Int40s                                                            | 0x0011 |
| * Int48s                                                            | 0x0012 |
| * Int56s                                                            | 0x0013 |
| * Int64s                                                            | 0x0014 |
| * Enum8                                                             | 0x0015 |
| * Enum16                                                            | 0x0016 |
| * FloatSingle                                                       | 0x0017 |
| * FloatDouble                                                       | 0x0018 |
| * OctetString                                                       | 0x0019 |
| * ListInt8u                                                         | 0x001A |
| * ListOctetString                                                   | 0x001B |
| * ListStructOctetString                                             | 0x001C |
| * LongOctetString                                                   | 0x001D |
| * CharString                                                        | 0x001E |
| * LongCharString                                                    | 0x001F |
| * EpochUs                                                           | 0x0020 |
| * EpochS                                                            | 0x0021 |
| * VendorId                                                          | 0x0022 |
| * ListNullablesAndOptionalsStruct                                   | 0x0023 |
| * EnumAttr                                                          | 0x0024 |
| * StructAttr                                                        | 0x0025 |
| * RangeRestrictedInt8u                                              | 0x0026 |
| * RangeRestrictedInt8s                                              | 0x0027 |
| * RangeRestrictedInt16u                                             | 0x0028 |
| * RangeRestrictedInt16s                                             | 0x0029 |
| * ListLongOctetString                                               | 0x002A |
| * TimedWriteBoolean                                                 | 0x0030 |
| * GeneralErrorBoolean                                               | 0x0031 |
| * ClusterErrorBoolean                                               | 0x0032 |
| * Unsupported                                                       | 0x00FF |
| * NullableBoolean                                                   | 0x8000 |
| * NullableBitmap8                                                   | 0x8001 |
| * NullableBitmap16                                                  | 0x8002 |
| * NullableBitmap32                                                  | 0x8003 |
| * NullableBitmap64                                                  | 0x8004 |
| * NullableInt8u                                                     | 0x8005 |
| * NullableInt16u                                                    | 0x8006 |
| * NullableInt24u                                                    | 0x8007 |
| * NullableInt32u                                                    | 0x8008 |
| * NullableInt40u                                                    | 0x8009 |
| * NullableInt48u                                                    | 0x800A |
| * NullableInt56u                                                    | 0x800B |
| * NullableInt64u                                                    | 0x800C |
| * NullableInt8s                                                     | 0x800D |
| * NullableInt16s                                                    | 0x800E |
| * NullableInt24s                                                    | 0x800F |
| * NullableInt32s                                                    | 0x8010 |
| * NullableInt40s                                                    | 0x8011 |
| * NullableInt48s                                                    | 0x8012 |
| * NullableInt56s                                                    | 0x8013 |
| * NullableInt64s                                                    | 0x8014 |
| * NullableEnum8                                                     | 0x8015 |
| * NullableEnum16                                                    | 0x8016 |
| * NullableFloatSingle                                               | 0x8017 |
| * NullableFloatDouble                                               | 0x8018 |
| * NullableOctetString                                               | 0x8019 |
| * NullableCharString                                                | 0x801E |
| * NullableEnumAttr                                                  | 0x8024 |
| * NullableStruct                                                    | 0x8025 |
| * NullableRangeRestrictedInt8u                                      | 0x8026 |
| * NullableRangeRestrictedInt8s                                      | 0x8027 |
| * NullableRangeRestrictedInt16u                                     | 0x8028 |
| * NullableRangeRestrictedInt16s                                     | 0x8029 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * TestEvent                                                         | 0x0001 |
| * TestFabricScopedEvent                                             | 0x0002 |
\*----------------------------------------------------------------------------*/

/*
 * Command SimpleStructEchoRequest
 */
class TestClusterSimpleStructEchoRequest : public ClusterCommand
{
public:
    TestClusterSimpleStructEchoRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("simple-struct-echo-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
    {
        AddArgument("Arg1", &mComplex_Arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000011) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000011, mRequest);
    }

private:
    chip::app::Clusters::TestCluster::Commands::SimpleStructEchoRequest::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type> mComplex_Arg1;
};

/*
 * Command Test
 */
class TestClusterTest : public ClusterCommand
{
public:
    TestClusterTest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("test", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::TestCluster::Commands::Test::Type mRequest;
};

/*
 * Command TestAddArguments
 */
class TestClusterTestAddArguments : public ClusterCommand
{
public:
    TestClusterTestAddArguments(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-add-arguments", credsIssuerConfig)
    {
        AddArgument("Arg1", 0, UINT8_MAX, &mRequest.arg1);
        AddArgument("Arg2", 0, UINT8_MAX, &mRequest.arg2);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000004) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000004, mRequest);
    }

private:
    chip::app::Clusters::TestCluster::Commands::TestAddArguments::Type mRequest;
};

/*
 * Command TestEmitTestEventRequest
 */
class TestClusterTestEmitTestEventRequest : public ClusterCommand
{
public:
    TestClusterTestEmitTestEventRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-emit-test-event-request", credsIssuerConfig)
    {
        AddArgument("Arg1", 0, UINT8_MAX, &mRequest.arg1);
        AddArgument("Arg2", 0, UINT8_MAX, &mRequest.arg2);
        AddArgument("Arg3", 0, 1, &mRequest.arg3);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000014) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000014, mRequest);
    }

private:
    chip::app::Clusters::TestCluster::Commands::TestEmitTestEventRequest::Type mRequest;
};

/*
 * Command TestEnumsRequest
 */
class TestClusterTestEnumsRequest : public ClusterCommand
{
public:
    TestClusterTestEnumsRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-enums-request", credsIssuerConfig)
    {
        AddArgument("Arg1", 0, UINT16_MAX, &mRequest.arg1);
        AddArgument("Arg2", 0, UINT8_MAX, &mRequest.arg2);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x0000000E) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x0000000E, mRequest);
    }

private:
    chip::app::Clusters::TestCluster::Commands::TestEnumsRequest::Type mRequest;
};

/*
 * Command TestListInt8UArgumentRequest
 */
class TestClusterTestListInt8UArgumentRequest : public ClusterCommand
{
public:
    TestClusterTestListInt8UArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-list-int8uargument-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
    {
        AddArgument("Arg1", &mComplex_Arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x0000000A) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x0000000A, mRequest);
    }

private:
    chip::app::Clusters::TestCluster::Commands::TestListInt8UArgumentRequest::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const uint8_t>> mComplex_Arg1;
};

/*
 * Command TestListInt8UReverseRequest
 */
class TestClusterTestListInt8UReverseRequest : public ClusterCommand
{
public:
    TestClusterTestListInt8UReverseRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-list-int8ureverse-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
    {
        AddArgument("Arg1", &mComplex_Arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x0000000D) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x0000000D, mRequest);
    }

private:
    chip::app::Clusters::TestCluster::Commands::TestListInt8UReverseRequest::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const uint8_t>> mComplex_Arg1;
};

/*
 * Command TestListNestedStructListArgumentRequest
 */
class TestClusterTestListNestedStructListArgumentRequest : public ClusterCommand
{
public:
    TestClusterTestListNestedStructListArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-list-nested-struct-list-argument-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
    {
        AddArgument("Arg1", &mComplex_Arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x0000000C) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x0000000C, mRequest);
    }

private:
    chip::app::Clusters::TestCluster::Commands::TestListNestedStructListArgumentRequest::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::TestCluster::Structs::NestedStructList::Type>>
        mComplex_Arg1;
};

/*
 * Command TestListStructArgumentRequest
 */
class TestClusterTestListStructArgumentRequest : public ClusterCommand
{
public:
    TestClusterTestListStructArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-list-struct-argument-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
    {
        AddArgument("Arg1", &mComplex_Arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000009) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000009, mRequest);
    }

private:
    chip::app::Clusters::TestCluster::Commands::TestListStructArgumentRequest::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type>>
        mComplex_Arg1;
};

/*
 * Command TestNestedStructArgumentRequest
 */
class TestClusterTestNestedStructArgumentRequest : public ClusterCommand
{
public:
    TestClusterTestNestedStructArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-nested-struct-argument-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
    {
        AddArgument("Arg1", &mComplex_Arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000008) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000008, mRequest);
    }

private:
    chip::app::Clusters::TestCluster::Commands::TestNestedStructArgumentRequest::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::TestCluster::Structs::NestedStruct::Type> mComplex_Arg1;
};

/*
 * Command TestNestedStructListArgumentRequest
 */
class TestClusterTestNestedStructListArgumentRequest : public ClusterCommand
{
public:
    TestClusterTestNestedStructListArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-nested-struct-list-argument-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
    {
        AddArgument("Arg1", &mComplex_Arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x0000000B) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x0000000B, mRequest);
    }

private:
    chip::app::Clusters::TestCluster::Commands::TestNestedStructListArgumentRequest::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::TestCluster::Structs::NestedStructList::Type> mComplex_Arg1;
};

/*
 * Command TestNotHandled
 */
class TestClusterTestNotHandled : public ClusterCommand
{
public:
    TestClusterTestNotHandled(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("test-not-handled", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000001) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000001, mRequest);
    }

private:
    chip::app::Clusters::TestCluster::Commands::TestNotHandled::Type mRequest;
};

/*
 * Command TestNullableOptionalRequest
 */
class TestClusterTestNullableOptionalRequest : public ClusterCommand
{
public:
    TestClusterTestNullableOptionalRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-nullable-optional-request", credsIssuerConfig)
    {
        AddArgument("Arg1", 0, UINT8_MAX, &mRequest.arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x0000000F) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x0000000F, mRequest);
    }

private:
    chip::app::Clusters::TestCluster::Commands::TestNullableOptionalRequest::Type mRequest;
};

/*
 * Command TestSimpleOptionalArgumentRequest
 */
class TestClusterTestSimpleOptionalArgumentRequest : public ClusterCommand
{
public:
    TestClusterTestSimpleOptionalArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-simple-optional-argument-request", credsIssuerConfig)
    {
        AddArgument("Arg1", 0, 1, &mRequest.arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000013) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000013, mRequest);
    }

private:
    chip::app::Clusters::TestCluster::Commands::TestSimpleOptionalArgumentRequest::Type mRequest;
};

/*
 * Command TestSpecific
 */
class TestClusterTestSpecific : public ClusterCommand
{
public:
    TestClusterTestSpecific(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("test-specific", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000002) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000002, mRequest);
    }

private:
    chip::app::Clusters::TestCluster::Commands::TestSpecific::Type mRequest;
};

/*
 * Command TestStructArgumentRequest
 */
class TestClusterTestStructArgumentRequest : public ClusterCommand
{
public:
    TestClusterTestStructArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-struct-argument-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
    {
        AddArgument("Arg1", &mComplex_Arg1);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000007) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000007, mRequest);
    }

private:
    chip::app::Clusters::TestCluster::Commands::TestStructArgumentRequest::Type mRequest;
    TypedComplexArgument<chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type> mComplex_Arg1;
};

/*
 * Command TestUnknownCommand
 */
class TestClusterTestUnknownCommand : public ClusterCommand
{
public:
    TestClusterTestUnknownCommand(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("test-unknown-command", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000003) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000003, mRequest);
    }

private:
    chip::app::Clusters::TestCluster::Commands::TestUnknownCommand::Type mRequest;
};

/*
 * Command TimedInvokeRequest
 */
class TestClusterTimedInvokeRequest : public ClusterCommand
{
public:
    TestClusterTimedInvokeRequest(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("timed-invoke-request", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000012) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000012, mRequest);
    }

private:
    chip::app::Clusters::TestCluster::Commands::TimedInvokeRequest::Type mRequest;
};

class WriteTestClusterBoolean : public WriteAttribute
{
public:
    WriteTestClusterBoolean(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Boolean", credsIssuerConfig)
    {
        AddArgument("attr-name", "boolean");
        AddArgument("attr-value", 0, 1, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterBoolean() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000000, mValue);
    }

private:
    bool mValue;
};

class WriteTestClusterBitmap8 : public WriteAttribute
{
public:
    WriteTestClusterBitmap8(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Bitmap8", credsIssuerConfig)
    {
        AddArgument("attr-name", "bitmap8");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterBitmap8() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000001, mValue);
    }

private:
    uint8_t mValue;
};

class WriteTestClusterBitmap16 : public WriteAttribute
{
public:
    WriteTestClusterBitmap16(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Bitmap16", credsIssuerConfig)
    {
        AddArgument("attr-name", "bitmap16");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterBitmap16() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000002, mValue);
    }

private:
    uint16_t mValue;
};

class WriteTestClusterBitmap32 : public WriteAttribute
{
public:
    WriteTestClusterBitmap32(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Bitmap32", credsIssuerConfig)
    {
        AddArgument("attr-name", "bitmap32");
        AddArgument("attr-value", 0, UINT32_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterBitmap32() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000003, mValue);
    }

private:
    uint32_t mValue;
};

class WriteTestClusterBitmap64 : public WriteAttribute
{
public:
    WriteTestClusterBitmap64(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Bitmap64", credsIssuerConfig)
    {
        AddArgument("attr-name", "bitmap64");
        AddArgument("attr-value", 0, UINT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterBitmap64() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000004, mValue);
    }

private:
    uint64_t mValue;
};

class WriteTestClusterInt8u : public WriteAttribute
{
public:
    WriteTestClusterInt8u(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int8u", credsIssuerConfig)
    {
        AddArgument("attr-name", "int8u");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterInt8u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000005, mValue);
    }

private:
    uint8_t mValue;
};

class WriteTestClusterInt16u : public WriteAttribute
{
public:
    WriteTestClusterInt16u(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int16u", credsIssuerConfig)
    {
        AddArgument("attr-name", "int16u");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterInt16u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000006, mValue);
    }

private:
    uint16_t mValue;
};

class WriteTestClusterInt24u : public WriteAttribute
{
public:
    WriteTestClusterInt24u(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int24u", credsIssuerConfig)
    {
        AddArgument("attr-name", "int24u");
        AddArgument("attr-value", 0, UINT32_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterInt24u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000007, mValue);
    }

private:
    uint32_t mValue;
};

class WriteTestClusterInt32u : public WriteAttribute
{
public:
    WriteTestClusterInt32u(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int32u", credsIssuerConfig)
    {
        AddArgument("attr-name", "int32u");
        AddArgument("attr-value", 0, UINT32_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterInt32u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000008, mValue);
    }

private:
    uint32_t mValue;
};

class WriteTestClusterInt40u : public WriteAttribute
{
public:
    WriteTestClusterInt40u(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int40u", credsIssuerConfig)
    {
        AddArgument("attr-name", "int40u");
        AddArgument("attr-value", 0, UINT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterInt40u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000009, mValue);
    }

private:
    uint64_t mValue;
};

class WriteTestClusterInt48u : public WriteAttribute
{
public:
    WriteTestClusterInt48u(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int48u", credsIssuerConfig)
    {
        AddArgument("attr-name", "int48u");
        AddArgument("attr-value", 0, UINT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterInt48u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000000A, mValue);
    }

private:
    uint64_t mValue;
};

class WriteTestClusterInt56u : public WriteAttribute
{
public:
    WriteTestClusterInt56u(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int56u", credsIssuerConfig)
    {
        AddArgument("attr-name", "int56u");
        AddArgument("attr-value", 0, UINT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterInt56u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000000B, mValue);
    }

private:
    uint64_t mValue;
};

class WriteTestClusterInt64u : public WriteAttribute
{
public:
    WriteTestClusterInt64u(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int64u", credsIssuerConfig)
    {
        AddArgument("attr-name", "int64u");
        AddArgument("attr-value", 0, UINT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterInt64u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000000C, mValue);
    }

private:
    uint64_t mValue;
};

class WriteTestClusterInt8s : public WriteAttribute
{
public:
    WriteTestClusterInt8s(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int8s", credsIssuerConfig)
    {
        AddArgument("attr-name", "int8s");
        AddArgument("attr-value", INT8_MIN, INT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterInt8s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000000D, mValue);
    }

private:
    int8_t mValue;
};

class WriteTestClusterInt16s : public WriteAttribute
{
public:
    WriteTestClusterInt16s(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int16s", credsIssuerConfig)
    {
        AddArgument("attr-name", "int16s");
        AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterInt16s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000000E, mValue);
    }

private:
    int16_t mValue;
};

class WriteTestClusterInt24s : public WriteAttribute
{
public:
    WriteTestClusterInt24s(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int24s", credsIssuerConfig)
    {
        AddArgument("attr-name", "int24s");
        AddArgument("attr-value", INT32_MIN, INT32_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterInt24s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000000F, mValue);
    }

private:
    int32_t mValue;
};

class WriteTestClusterInt32s : public WriteAttribute
{
public:
    WriteTestClusterInt32s(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int32s", credsIssuerConfig)
    {
        AddArgument("attr-name", "int32s");
        AddArgument("attr-value", INT32_MIN, INT32_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterInt32s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000010, mValue);
    }

private:
    int32_t mValue;
};

class WriteTestClusterInt40s : public WriteAttribute
{
public:
    WriteTestClusterInt40s(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int40s", credsIssuerConfig)
    {
        AddArgument("attr-name", "int40s");
        AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterInt40s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000011, mValue);
    }

private:
    int64_t mValue;
};

class WriteTestClusterInt48s : public WriteAttribute
{
public:
    WriteTestClusterInt48s(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int48s", credsIssuerConfig)
    {
        AddArgument("attr-name", "int48s");
        AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterInt48s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000012, mValue);
    }

private:
    int64_t mValue;
};

class WriteTestClusterInt56s : public WriteAttribute
{
public:
    WriteTestClusterInt56s(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int56s", credsIssuerConfig)
    {
        AddArgument("attr-name", "int56s");
        AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterInt56s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000013, mValue);
    }

private:
    int64_t mValue;
};

class WriteTestClusterInt64s : public WriteAttribute
{
public:
    WriteTestClusterInt64s(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int64s", credsIssuerConfig)
    {
        AddArgument("attr-name", "int64s");
        AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterInt64s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000014, mValue);
    }

private:
    int64_t mValue;
};

class WriteTestClusterEnum8 : public WriteAttribute
{
public:
    WriteTestClusterEnum8(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Enum8", credsIssuerConfig)
    {
        AddArgument("attr-name", "enum8");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterEnum8() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000015, mValue);
    }

private:
    uint8_t mValue;
};

class WriteTestClusterEnum16 : public WriteAttribute
{
public:
    WriteTestClusterEnum16(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Enum16", credsIssuerConfig)
    {
        AddArgument("attr-name", "enum16");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterEnum16() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000016, mValue);
    }

private:
    uint16_t mValue;
};

class WriteTestClusterFloatSingle : public WriteAttribute
{
public:
    WriteTestClusterFloatSingle(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("FloatSingle", credsIssuerConfig)
    {
        AddArgument("attr-name", "float-single");
        AddArgument("attr-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(), &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterFloatSingle() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000017, mValue);
    }

private:
    float mValue;
};

class WriteTestClusterFloatDouble : public WriteAttribute
{
public:
    WriteTestClusterFloatDouble(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("FloatDouble", credsIssuerConfig)
    {
        AddArgument("attr-name", "float-double");
        AddArgument("attr-value", -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity(), &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterFloatDouble() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000018, mValue);
    }

private:
    double mValue;
};

class WriteTestClusterOctetString : public WriteAttribute
{
public:
    WriteTestClusterOctetString(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("OctetString", credsIssuerConfig)
    {
        AddArgument("attr-name", "octet-string");
        AddArgument("attr-value", &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterOctetString() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000019, mValue);
    }

private:
    chip::ByteSpan mValue;
};

class WriteTestClusterListInt8u : public WriteAttribute
{
public:
    WriteTestClusterListInt8u(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("ListInt8u", credsIssuerConfig), mComplex(&mValue)
    {
        AddArgument("attr-name", "list-int8u");
        AddArgument("attr-value", &mComplex);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterListInt8u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000001A, mValue);
    }

private:
    chip::app::DataModel::List<const uint8_t> mValue;
    TypedComplexArgument<chip::app::DataModel::List<const uint8_t>> mComplex;
};

class WriteTestClusterListOctetString : public WriteAttribute
{
public:
    WriteTestClusterListOctetString(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("ListOctetString", credsIssuerConfig), mComplex(&mValue)
    {
        AddArgument("attr-name", "list-octet-string");
        AddArgument("attr-value", &mComplex);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterListOctetString() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000001B, mValue);
    }

private:
    chip::app::DataModel::List<const chip::ByteSpan> mValue;
    TypedComplexArgument<chip::app::DataModel::List<const chip::ByteSpan>> mComplex;
};

class WriteTestClusterListStructOctetString : public WriteAttribute
{
public:
    WriteTestClusterListStructOctetString(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("ListStructOctetString", credsIssuerConfig), mComplex(&mValue)
    {
        AddArgument("attr-name", "list-struct-octet-string");
        AddArgument("attr-value", &mComplex);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterListStructOctetString() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000001C, mValue);
    }

private:
    chip::app::DataModel::List<const chip::app::Clusters::TestCluster::Structs::TestListStructOctet::Type> mValue;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::TestCluster::Structs::TestListStructOctet::Type>>
        mComplex;
};

class WriteTestClusterLongOctetString : public WriteAttribute
{
public:
    WriteTestClusterLongOctetString(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("LongOctetString", credsIssuerConfig)
    {
        AddArgument("attr-name", "long-octet-string");
        AddArgument("attr-value", &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterLongOctetString() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000001D, mValue);
    }

private:
    chip::ByteSpan mValue;
};

class WriteTestClusterCharString : public WriteAttribute
{
public:
    WriteTestClusterCharString(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("CharString", credsIssuerConfig)
    {
        AddArgument("attr-name", "char-string");
        AddArgument("attr-value", &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterCharString() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000001E, mValue);
    }

private:
    chip::CharSpan mValue;
};

class WriteTestClusterLongCharString : public WriteAttribute
{
public:
    WriteTestClusterLongCharString(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("LongCharString", credsIssuerConfig)
    {
        AddArgument("attr-name", "long-char-string");
        AddArgument("attr-value", &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterLongCharString() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000001F, mValue);
    }

private:
    chip::CharSpan mValue;
};

class WriteTestClusterEpochUs : public WriteAttribute
{
public:
    WriteTestClusterEpochUs(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("EpochUs", credsIssuerConfig)
    {
        AddArgument("attr-name", "epoch-us");
        AddArgument("attr-value", 0, UINT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterEpochUs() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000020, mValue);
    }

private:
    uint64_t mValue;
};

class WriteTestClusterEpochS : public WriteAttribute
{
public:
    WriteTestClusterEpochS(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("EpochS", credsIssuerConfig)
    {
        AddArgument("attr-name", "epoch-s");
        AddArgument("attr-value", 0, UINT32_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterEpochS() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000021, mValue);
    }

private:
    uint32_t mValue;
};

class WriteTestClusterVendorId : public WriteAttribute
{
public:
    WriteTestClusterVendorId(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("VendorId", credsIssuerConfig)
    {
        AddArgument("attr-name", "vendor-id");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterVendorId() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000022, mValue);
    }

private:
    chip::VendorId mValue;
};

class WriteTestClusterListNullablesAndOptionalsStruct : public WriteAttribute
{
public:
    WriteTestClusterListNullablesAndOptionalsStruct(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("ListNullablesAndOptionalsStruct", credsIssuerConfig), mComplex(&mValue)
    {
        AddArgument("attr-name", "list-nullables-and-optionals-struct");
        AddArgument("attr-value", &mComplex);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterListNullablesAndOptionalsStruct() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000023, mValue);
    }

private:
    chip::app::DataModel::List<const chip::app::Clusters::TestCluster::Structs::NullablesAndOptionalsStruct::Type> mValue;
    TypedComplexArgument<
        chip::app::DataModel::List<const chip::app::Clusters::TestCluster::Structs::NullablesAndOptionalsStruct::Type>>
        mComplex;
};

class WriteTestClusterEnumAttr : public WriteAttribute
{
public:
    WriteTestClusterEnumAttr(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("EnumAttr", credsIssuerConfig)
    {
        AddArgument("attr-name", "enum-attr");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterEnumAttr() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000024, mValue);
    }

private:
    chip::app::Clusters::TestCluster::SimpleEnum mValue;
};

class WriteTestClusterStructAttr : public WriteAttribute
{
public:
    WriteTestClusterStructAttr(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("StructAttr", credsIssuerConfig), mComplex(&mValue)
    {
        AddArgument("attr-name", "struct-attr");
        AddArgument("attr-value", &mComplex);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterStructAttr() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000025, mValue);
    }

private:
    chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type mValue;
    TypedComplexArgument<chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type> mComplex;
};

class WriteTestClusterRangeRestrictedInt8u : public WriteAttribute
{
public:
    WriteTestClusterRangeRestrictedInt8u(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("RangeRestrictedInt8u", credsIssuerConfig)
    {
        AddArgument("attr-name", "range-restricted-int8u");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterRangeRestrictedInt8u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000026, mValue);
    }

private:
    uint8_t mValue;
};

class WriteTestClusterRangeRestrictedInt8s : public WriteAttribute
{
public:
    WriteTestClusterRangeRestrictedInt8s(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("RangeRestrictedInt8s", credsIssuerConfig)
    {
        AddArgument("attr-name", "range-restricted-int8s");
        AddArgument("attr-value", INT8_MIN, INT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterRangeRestrictedInt8s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000027, mValue);
    }

private:
    int8_t mValue;
};

class WriteTestClusterRangeRestrictedInt16u : public WriteAttribute
{
public:
    WriteTestClusterRangeRestrictedInt16u(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("RangeRestrictedInt16u", credsIssuerConfig)
    {
        AddArgument("attr-name", "range-restricted-int16u");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterRangeRestrictedInt16u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000028, mValue);
    }

private:
    uint16_t mValue;
};

class WriteTestClusterRangeRestrictedInt16s : public WriteAttribute
{
public:
    WriteTestClusterRangeRestrictedInt16s(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("RangeRestrictedInt16s", credsIssuerConfig)
    {
        AddArgument("attr-name", "range-restricted-int16s");
        AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterRangeRestrictedInt16s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000029, mValue);
    }

private:
    int16_t mValue;
};

class WriteTestClusterTimedWriteBoolean : public WriteAttribute
{
public:
    WriteTestClusterTimedWriteBoolean(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("TimedWriteBoolean", credsIssuerConfig)
    {
        AddArgument("attr-name", "timed-write-boolean");
        AddArgument("attr-value", 0, 1, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterTimedWriteBoolean() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000030, mValue);
    }

private:
    bool mValue;
};

class WriteTestClusterGeneralErrorBoolean : public WriteAttribute
{
public:
    WriteTestClusterGeneralErrorBoolean(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("GeneralErrorBoolean", credsIssuerConfig)
    {
        AddArgument("attr-name", "general-error-boolean");
        AddArgument("attr-value", 0, 1, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterGeneralErrorBoolean() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000031, mValue);
    }

private:
    bool mValue;
};

class WriteTestClusterClusterErrorBoolean : public WriteAttribute
{
public:
    WriteTestClusterClusterErrorBoolean(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("ClusterErrorBoolean", credsIssuerConfig)
    {
        AddArgument("attr-name", "cluster-error-boolean");
        AddArgument("attr-value", 0, 1, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterClusterErrorBoolean() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000032, mValue);
    }

private:
    bool mValue;
};

class WriteTestClusterUnsupported : public WriteAttribute
{
public:
    WriteTestClusterUnsupported(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Unsupported", credsIssuerConfig)
    {
        AddArgument("attr-name", "unsupported");
        AddArgument("attr-value", 0, 1, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterUnsupported() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x000000FF, mValue);
    }

private:
    bool mValue;
};

class WriteTestClusterNullableBoolean : public WriteAttribute
{
public:
    WriteTestClusterNullableBoolean(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableBoolean", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-boolean");
        AddArgument("attr-value", 0, 1, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableBoolean() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008000, mValue);
    }

private:
    chip::app::DataModel::Nullable<bool> mValue;
};

class WriteTestClusterNullableBitmap8 : public WriteAttribute
{
public:
    WriteTestClusterNullableBitmap8(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableBitmap8", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-bitmap8");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableBitmap8() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008001, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint8_t> mValue;
};

class WriteTestClusterNullableBitmap16 : public WriteAttribute
{
public:
    WriteTestClusterNullableBitmap16(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableBitmap16", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-bitmap16");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableBitmap16() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008002, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint16_t> mValue;
};

class WriteTestClusterNullableBitmap32 : public WriteAttribute
{
public:
    WriteTestClusterNullableBitmap32(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableBitmap32", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-bitmap32");
        AddArgument("attr-value", 0, UINT32_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableBitmap32() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008003, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint32_t> mValue;
};

class WriteTestClusterNullableBitmap64 : public WriteAttribute
{
public:
    WriteTestClusterNullableBitmap64(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableBitmap64", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-bitmap64");
        AddArgument("attr-value", 0, UINT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableBitmap64() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008004, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint64_t> mValue;
};

class WriteTestClusterNullableInt8u : public WriteAttribute
{
public:
    WriteTestClusterNullableInt8u(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("NullableInt8u", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-int8u");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableInt8u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008005, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint8_t> mValue;
};

class WriteTestClusterNullableInt16u : public WriteAttribute
{
public:
    WriteTestClusterNullableInt16u(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableInt16u", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-int16u");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableInt16u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008006, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint16_t> mValue;
};

class WriteTestClusterNullableInt24u : public WriteAttribute
{
public:
    WriteTestClusterNullableInt24u(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableInt24u", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-int24u");
        AddArgument("attr-value", 0, UINT32_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableInt24u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008007, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint32_t> mValue;
};

class WriteTestClusterNullableInt32u : public WriteAttribute
{
public:
    WriteTestClusterNullableInt32u(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableInt32u", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-int32u");
        AddArgument("attr-value", 0, UINT32_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableInt32u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008008, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint32_t> mValue;
};

class WriteTestClusterNullableInt40u : public WriteAttribute
{
public:
    WriteTestClusterNullableInt40u(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableInt40u", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-int40u");
        AddArgument("attr-value", 0, UINT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableInt40u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008009, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint64_t> mValue;
};

class WriteTestClusterNullableInt48u : public WriteAttribute
{
public:
    WriteTestClusterNullableInt48u(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableInt48u", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-int48u");
        AddArgument("attr-value", 0, UINT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableInt48u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000800A, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint64_t> mValue;
};

class WriteTestClusterNullableInt56u : public WriteAttribute
{
public:
    WriteTestClusterNullableInt56u(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableInt56u", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-int56u");
        AddArgument("attr-value", 0, UINT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableInt56u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000800B, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint64_t> mValue;
};

class WriteTestClusterNullableInt64u : public WriteAttribute
{
public:
    WriteTestClusterNullableInt64u(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableInt64u", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-int64u");
        AddArgument("attr-value", 0, UINT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableInt64u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000800C, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint64_t> mValue;
};

class WriteTestClusterNullableInt8s : public WriteAttribute
{
public:
    WriteTestClusterNullableInt8s(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("NullableInt8s", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-int8s");
        AddArgument("attr-value", INT8_MIN, INT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableInt8s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000800D, mValue);
    }

private:
    chip::app::DataModel::Nullable<int8_t> mValue;
};

class WriteTestClusterNullableInt16s : public WriteAttribute
{
public:
    WriteTestClusterNullableInt16s(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableInt16s", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-int16s");
        AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableInt16s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000800E, mValue);
    }

private:
    chip::app::DataModel::Nullable<int16_t> mValue;
};

class WriteTestClusterNullableInt24s : public WriteAttribute
{
public:
    WriteTestClusterNullableInt24s(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableInt24s", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-int24s");
        AddArgument("attr-value", INT32_MIN, INT32_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableInt24s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000800F, mValue);
    }

private:
    chip::app::DataModel::Nullable<int32_t> mValue;
};

class WriteTestClusterNullableInt32s : public WriteAttribute
{
public:
    WriteTestClusterNullableInt32s(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableInt32s", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-int32s");
        AddArgument("attr-value", INT32_MIN, INT32_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableInt32s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008010, mValue);
    }

private:
    chip::app::DataModel::Nullable<int32_t> mValue;
};

class WriteTestClusterNullableInt40s : public WriteAttribute
{
public:
    WriteTestClusterNullableInt40s(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableInt40s", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-int40s");
        AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableInt40s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008011, mValue);
    }

private:
    chip::app::DataModel::Nullable<int64_t> mValue;
};

class WriteTestClusterNullableInt48s : public WriteAttribute
{
public:
    WriteTestClusterNullableInt48s(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableInt48s", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-int48s");
        AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableInt48s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008012, mValue);
    }

private:
    chip::app::DataModel::Nullable<int64_t> mValue;
};

class WriteTestClusterNullableInt56s : public WriteAttribute
{
public:
    WriteTestClusterNullableInt56s(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableInt56s", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-int56s");
        AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableInt56s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008013, mValue);
    }

private:
    chip::app::DataModel::Nullable<int64_t> mValue;
};

class WriteTestClusterNullableInt64s : public WriteAttribute
{
public:
    WriteTestClusterNullableInt64s(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableInt64s", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-int64s");
        AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableInt64s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008014, mValue);
    }

private:
    chip::app::DataModel::Nullable<int64_t> mValue;
};

class WriteTestClusterNullableEnum8 : public WriteAttribute
{
public:
    WriteTestClusterNullableEnum8(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("NullableEnum8", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-enum8");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableEnum8() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008015, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint8_t> mValue;
};

class WriteTestClusterNullableEnum16 : public WriteAttribute
{
public:
    WriteTestClusterNullableEnum16(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableEnum16", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-enum16");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableEnum16() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008016, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint16_t> mValue;
};

class WriteTestClusterNullableFloatSingle : public WriteAttribute
{
public:
    WriteTestClusterNullableFloatSingle(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableFloatSingle", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-float-single");
        AddArgument("attr-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(), &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableFloatSingle() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008017, mValue);
    }

private:
    chip::app::DataModel::Nullable<float> mValue;
};

class WriteTestClusterNullableFloatDouble : public WriteAttribute
{
public:
    WriteTestClusterNullableFloatDouble(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableFloatDouble", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-float-double");
        AddArgument("attr-value", -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity(), &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableFloatDouble() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008018, mValue);
    }

private:
    chip::app::DataModel::Nullable<double> mValue;
};

class WriteTestClusterNullableOctetString : public WriteAttribute
{
public:
    WriteTestClusterNullableOctetString(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableOctetString", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-octet-string");
        AddArgument("attr-value", &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableOctetString() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008019, mValue);
    }

private:
    chip::app::DataModel::Nullable<chip::ByteSpan> mValue;
};

class WriteTestClusterNullableCharString : public WriteAttribute
{
public:
    WriteTestClusterNullableCharString(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableCharString", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-char-string");
        AddArgument("attr-value", &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableCharString() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000801E, mValue);
    }

private:
    chip::app::DataModel::Nullable<chip::CharSpan> mValue;
};

class WriteTestClusterNullableEnumAttr : public WriteAttribute
{
public:
    WriteTestClusterNullableEnumAttr(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableEnumAttr", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-enum-attr");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableEnumAttr() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008024, mValue);
    }

private:
    chip::app::DataModel::Nullable<chip::app::Clusters::TestCluster::SimpleEnum> mValue;
};

class WriteTestClusterNullableStruct : public WriteAttribute
{
public:
    WriteTestClusterNullableStruct(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableStruct", credsIssuerConfig), mComplex(&mValue)
    {
        AddArgument("attr-name", "nullable-struct");
        AddArgument("attr-value", &mComplex);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableStruct() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008025, mValue);
    }

private:
    chip::app::DataModel::Nullable<chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type> mValue;
    TypedComplexArgument<chip::app::DataModel::Nullable<chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type>> mComplex;
};

class WriteTestClusterNullableRangeRestrictedInt8u : public WriteAttribute
{
public:
    WriteTestClusterNullableRangeRestrictedInt8u(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableRangeRestrictedInt8u", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-range-restricted-int8u");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableRangeRestrictedInt8u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008026, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint8_t> mValue;
};

class WriteTestClusterNullableRangeRestrictedInt8s : public WriteAttribute
{
public:
    WriteTestClusterNullableRangeRestrictedInt8s(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableRangeRestrictedInt8s", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-range-restricted-int8s");
        AddArgument("attr-value", INT8_MIN, INT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableRangeRestrictedInt8s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008027, mValue);
    }

private:
    chip::app::DataModel::Nullable<int8_t> mValue;
};

class WriteTestClusterNullableRangeRestrictedInt16u : public WriteAttribute
{
public:
    WriteTestClusterNullableRangeRestrictedInt16u(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableRangeRestrictedInt16u", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-range-restricted-int16u");
        AddArgument("attr-value", 0, UINT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableRangeRestrictedInt16u() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008028, mValue);
    }

private:
    chip::app::DataModel::Nullable<uint16_t> mValue;
};

class WriteTestClusterNullableRangeRestrictedInt16s : public WriteAttribute
{
public:
    WriteTestClusterNullableRangeRestrictedInt16s(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("NullableRangeRestrictedInt16s", credsIssuerConfig)
    {
        AddArgument("attr-name", "nullable-range-restricted-int16s");
        AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTestClusterNullableRangeRestrictedInt16s() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008029, mValue);
    }

private:
    chip::app::DataModel::Nullable<int16_t> mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster Thermostat                                                  | 0x0201 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ClearWeeklySchedule                                               |   0x03 |
| * GetRelayStatusLog                                                 |   0x04 |
| * GetWeeklySchedule                                                 |   0x02 |
| * SetWeeklySchedule                                                 |   0x01 |
| * SetpointRaiseLower                                                |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * LocalTemperature                                                  | 0x0000 |
| * AbsMinHeatSetpointLimit                                           | 0x0003 |
| * AbsMaxHeatSetpointLimit                                           | 0x0004 |
| * AbsMinCoolSetpointLimit                                           | 0x0005 |
| * AbsMaxCoolSetpointLimit                                           | 0x0006 |
| * OccupiedCoolingSetpoint                                           | 0x0011 |
| * OccupiedHeatingSetpoint                                           | 0x0012 |
| * MinHeatSetpointLimit                                              | 0x0015 |
| * MaxHeatSetpointLimit                                              | 0x0016 |
| * MinCoolSetpointLimit                                              | 0x0017 |
| * MaxCoolSetpointLimit                                              | 0x0018 |
| * MinSetpointDeadBand                                               | 0x0019 |
| * ControlSequenceOfOperation                                        | 0x001B |
| * SystemMode                                                        | 0x001C |
| * StartOfWeek                                                       | 0x0020 |
| * NumberOfWeeklyTransitions                                         | 0x0021 |
| * NumberOfDailyTransitions                                          | 0x0022 |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command ClearWeeklySchedule
 */
class ThermostatClearWeeklySchedule : public ClusterCommand
{
public:
    ThermostatClearWeeklySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("clear-weekly-schedule", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000201) command (0x00000003) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000201, 0x00000003, mRequest);
    }

private:
    chip::app::Clusters::Thermostat::Commands::ClearWeeklySchedule::Type mRequest;
};

/*
 * Command GetRelayStatusLog
 */
class ThermostatGetRelayStatusLog : public ClusterCommand
{
public:
    ThermostatGetRelayStatusLog(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("get-relay-status-log", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000201) command (0x00000004) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000201, 0x00000004, mRequest);
    }

private:
    chip::app::Clusters::Thermostat::Commands::GetRelayStatusLog::Type mRequest;
};

/*
 * Command GetWeeklySchedule
 */
class ThermostatGetWeeklySchedule : public ClusterCommand
{
public:
    ThermostatGetWeeklySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("get-weekly-schedule", credsIssuerConfig)
    {
        AddArgument("DaysToReturn", 0, UINT8_MAX, &mRequest.daysToReturn);
        AddArgument("ModeToReturn", 0, UINT8_MAX, &mRequest.modeToReturn);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000201) command (0x00000002) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000201, 0x00000002, mRequest);
    }

private:
    chip::app::Clusters::Thermostat::Commands::GetWeeklySchedule::Type mRequest;
};

/*
 * Command SetWeeklySchedule
 */
class ThermostatSetWeeklySchedule : public ClusterCommand
{
public:
    ThermostatSetWeeklySchedule(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("set-weekly-schedule", credsIssuerConfig), mComplex_Payload(&mRequest.payload)
    {
        AddArgument("NumberOfTransitionsForSequence", 0, UINT8_MAX, &mRequest.numberOfTransitionsForSequence);
        AddArgument("DayOfWeekForSequence", 0, UINT8_MAX, &mRequest.dayOfWeekForSequence);
        AddArgument("ModeForSequence", 0, UINT8_MAX, &mRequest.modeForSequence);
        AddArgument("Payload", &mComplex_Payload);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000201) command (0x00000001) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000201, 0x00000001, mRequest);
    }

private:
    chip::app::Clusters::Thermostat::Commands::SetWeeklySchedule::Type mRequest;
    TypedComplexArgument<chip::app::DataModel::List<const uint8_t>> mComplex_Payload;
};

/*
 * Command SetpointRaiseLower
 */
class ThermostatSetpointRaiseLower : public ClusterCommand
{
public:
    ThermostatSetpointRaiseLower(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("setpoint-raise-lower", credsIssuerConfig)
    {
        AddArgument("Mode", 0, UINT8_MAX, &mRequest.mode);
        AddArgument("Amount", INT8_MIN, INT8_MAX, &mRequest.amount);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000201) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000201, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::Thermostat::Commands::SetpointRaiseLower::Type mRequest;
};

class WriteThermostatOccupiedCoolingSetpoint : public WriteAttribute
{
public:
    WriteThermostatOccupiedCoolingSetpoint(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("OccupiedCoolingSetpoint", credsIssuerConfig)
    {
        AddArgument("attr-name", "occupied-cooling-setpoint");
        AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteThermostatOccupiedCoolingSetpoint() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000201, 0x00000011, mValue);
    }

private:
    int16_t mValue;
};

class WriteThermostatOccupiedHeatingSetpoint : public WriteAttribute
{
public:
    WriteThermostatOccupiedHeatingSetpoint(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("OccupiedHeatingSetpoint", credsIssuerConfig)
    {
        AddArgument("attr-name", "occupied-heating-setpoint");
        AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteThermostatOccupiedHeatingSetpoint() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000201, 0x00000012, mValue);
    }

private:
    int16_t mValue;
};

class WriteThermostatMinHeatSetpointLimit : public WriteAttribute
{
public:
    WriteThermostatMinHeatSetpointLimit(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("MinHeatSetpointLimit", credsIssuerConfig)
    {
        AddArgument("attr-name", "min-heat-setpoint-limit");
        AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteThermostatMinHeatSetpointLimit() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000201, 0x00000015, mValue);
    }

private:
    int16_t mValue;
};

class WriteThermostatMaxHeatSetpointLimit : public WriteAttribute
{
public:
    WriteThermostatMaxHeatSetpointLimit(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("MaxHeatSetpointLimit", credsIssuerConfig)
    {
        AddArgument("attr-name", "max-heat-setpoint-limit");
        AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteThermostatMaxHeatSetpointLimit() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000201, 0x00000016, mValue);
    }

private:
    int16_t mValue;
};

class WriteThermostatMinCoolSetpointLimit : public WriteAttribute
{
public:
    WriteThermostatMinCoolSetpointLimit(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("MinCoolSetpointLimit", credsIssuerConfig)
    {
        AddArgument("attr-name", "min-cool-setpoint-limit");
        AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteThermostatMinCoolSetpointLimit() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000201, 0x00000017, mValue);
    }

private:
    int16_t mValue;
};

class WriteThermostatMaxCoolSetpointLimit : public WriteAttribute
{
public:
    WriteThermostatMaxCoolSetpointLimit(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("MaxCoolSetpointLimit", credsIssuerConfig)
    {
        AddArgument("attr-name", "max-cool-setpoint-limit");
        AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteThermostatMaxCoolSetpointLimit() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000201, 0x00000018, mValue);
    }

private:
    int16_t mValue;
};

class WriteThermostatMinSetpointDeadBand : public WriteAttribute
{
public:
    WriteThermostatMinSetpointDeadBand(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("MinSetpointDeadBand", credsIssuerConfig)
    {
        AddArgument("attr-name", "min-setpoint-dead-band");
        AddArgument("attr-value", INT8_MIN, INT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteThermostatMinSetpointDeadBand() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000201, 0x00000019, mValue);
    }

private:
    int8_t mValue;
};

class WriteThermostatControlSequenceOfOperation : public WriteAttribute
{
public:
    WriteThermostatControlSequenceOfOperation(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("ControlSequenceOfOperation", credsIssuerConfig)
    {
        AddArgument("attr-name", "control-sequence-of-operation");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteThermostatControlSequenceOfOperation() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000201, 0x0000001B, mValue);
    }

private:
    uint8_t mValue;
};

class WriteThermostatSystemMode : public WriteAttribute
{
public:
    WriteThermostatSystemMode(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("SystemMode", credsIssuerConfig)
    {
        AddArgument("attr-name", "system-mode");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteThermostatSystemMode() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000201, 0x0000001C, mValue);
    }

private:
    uint8_t mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster ThermostatUserInterfaceConfiguration                        | 0x0204 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * TemperatureDisplayMode                                            | 0x0000 |
| * KeypadLockout                                                     | 0x0001 |
| * ScheduleProgrammingVisibility                                     | 0x0002 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

class WriteThermostatUserInterfaceConfigurationTemperatureDisplayMode : public WriteAttribute
{
public:
    WriteThermostatUserInterfaceConfigurationTemperatureDisplayMode(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("TemperatureDisplayMode", credsIssuerConfig)
    {
        AddArgument("attr-name", "temperature-display-mode");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteThermostatUserInterfaceConfigurationTemperatureDisplayMode() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000204, 0x00000000, mValue);
    }

private:
    uint8_t mValue;
};

class WriteThermostatUserInterfaceConfigurationKeypadLockout : public WriteAttribute
{
public:
    WriteThermostatUserInterfaceConfigurationKeypadLockout(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("KeypadLockout", credsIssuerConfig)
    {
        AddArgument("attr-name", "keypad-lockout");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteThermostatUserInterfaceConfigurationKeypadLockout() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000204, 0x00000001, mValue);
    }

private:
    uint8_t mValue;
};

class WriteThermostatUserInterfaceConfigurationScheduleProgrammingVisibility : public WriteAttribute
{
public:
    WriteThermostatUserInterfaceConfigurationScheduleProgrammingVisibility(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("ScheduleProgrammingVisibility", credsIssuerConfig)
    {
        AddArgument("attr-name", "schedule-programming-visibility");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteThermostatUserInterfaceConfigurationScheduleProgrammingVisibility() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000204, 0x00000002, mValue);
    }

private:
    uint8_t mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster ThreadNetworkDiagnostics                                    | 0x0035 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ResetCounts                                                       |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Channel                                                           | 0x0000 |
| * RoutingRole                                                       | 0x0001 |
| * NetworkName                                                       | 0x0002 |
| * PanId                                                             | 0x0003 |
| * ExtendedPanId                                                     | 0x0004 |
| * MeshLocalPrefix                                                   | 0x0005 |
| * OverrunCount                                                      | 0x0006 |
| * NeighborTableList                                                 | 0x0007 |
| * RouteTableList                                                    | 0x0008 |
| * PartitionId                                                       | 0x0009 |
| * Weighting                                                         | 0x000A |
| * DataVersion                                                       | 0x000B |
| * StableDataVersion                                                 | 0x000C |
| * LeaderRouterId                                                    | 0x000D |
| * DetachedRoleCount                                                 | 0x000E |
| * ChildRoleCount                                                    | 0x000F |
| * RouterRoleCount                                                   | 0x0010 |
| * LeaderRoleCount                                                   | 0x0011 |
| * AttachAttemptCount                                                | 0x0012 |
| * PartitionIdChangeCount                                            | 0x0013 |
| * BetterPartitionAttachAttemptCount                                 | 0x0014 |
| * ParentChangeCount                                                 | 0x0015 |
| * TxTotalCount                                                      | 0x0016 |
| * TxUnicastCount                                                    | 0x0017 |
| * TxBroadcastCount                                                  | 0x0018 |
| * TxAckRequestedCount                                               | 0x0019 |
| * TxAckedCount                                                      | 0x001A |
| * TxNoAckRequestedCount                                             | 0x001B |
| * TxDataCount                                                       | 0x001C |
| * TxDataPollCount                                                   | 0x001D |
| * TxBeaconCount                                                     | 0x001E |
| * TxBeaconRequestCount                                              | 0x001F |
| * TxOtherCount                                                      | 0x0020 |
| * TxRetryCount                                                      | 0x0021 |
| * TxDirectMaxRetryExpiryCount                                       | 0x0022 |
| * TxIndirectMaxRetryExpiryCount                                     | 0x0023 |
| * TxErrCcaCount                                                     | 0x0024 |
| * TxErrAbortCount                                                   | 0x0025 |
| * TxErrBusyChannelCount                                             | 0x0026 |
| * RxTotalCount                                                      | 0x0027 |
| * RxUnicastCount                                                    | 0x0028 |
| * RxBroadcastCount                                                  | 0x0029 |
| * RxDataCount                                                       | 0x002A |
| * RxDataPollCount                                                   | 0x002B |
| * RxBeaconCount                                                     | 0x002C |
| * RxBeaconRequestCount                                              | 0x002D |
| * RxOtherCount                                                      | 0x002E |
| * RxAddressFilteredCount                                            | 0x002F |
| * RxDestAddrFilteredCount                                           | 0x0030 |
| * RxDuplicatedCount                                                 | 0x0031 |
| * RxErrNoFrameCount                                                 | 0x0032 |
| * RxErrUnknownNeighborCount                                         | 0x0033 |
| * RxErrInvalidSrcAddrCount                                          | 0x0034 |
| * RxErrSecCount                                                     | 0x0035 |
| * RxErrFcsCount                                                     | 0x0036 |
| * RxErrOtherCount                                                   | 0x0037 |
| * ActiveTimestamp                                                   | 0x0038 |
| * PendingTimestamp                                                  | 0x0039 |
| * Delay                                                             | 0x003A |
| * SecurityPolicy                                                    | 0x003B |
| * ChannelMask                                                       | 0x003C |
| * OperationalDatasetComponents                                      | 0x003D |
| * ActiveNetworkFaultsList                                           | 0x003E |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * ConnectionStatus                                                  | 0x0000 |
\*----------------------------------------------------------------------------*/

/*
 * Command ResetCounts
 */
class ThreadNetworkDiagnosticsResetCounts : public ClusterCommand
{
public:
    ThreadNetworkDiagnosticsResetCounts(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("reset-counts", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000035) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000035, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::ThreadNetworkDiagnostics::Commands::ResetCounts::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster TimeFormatLocalization                                      | 0x002C |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * HourFormat                                                        | 0x0000 |
| * ActiveCalendarType                                                | 0x0001 |
| * SupportedCalendarTypes                                            | 0x0002 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

class WriteTimeFormatLocalizationHourFormat : public WriteAttribute
{
public:
    WriteTimeFormatLocalizationHourFormat(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("HourFormat", credsIssuerConfig)
    {
        AddArgument("attr-name", "hour-format");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTimeFormatLocalizationHourFormat() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000002C, 0x00000000, mValue);
    }

private:
    chip::app::Clusters::TimeFormatLocalization::HourFormat mValue;
};

class WriteTimeFormatLocalizationActiveCalendarType : public WriteAttribute
{
public:
    WriteTimeFormatLocalizationActiveCalendarType(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("ActiveCalendarType", credsIssuerConfig)
    {
        AddArgument("attr-name", "active-calendar-type");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteTimeFormatLocalizationActiveCalendarType() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000002C, 0x00000001, mValue);
    }

private:
    chip::app::Clusters::TimeFormatLocalization::CalendarType mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster UnitLocalization                                            | 0x002D |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * TemperatureUnit                                                   | 0x0000 |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

class WriteUnitLocalizationTemperatureUnit : public WriteAttribute
{
public:
    WriteUnitLocalizationTemperatureUnit(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("TemperatureUnit", credsIssuerConfig)
    {
        AddArgument("attr-name", "temperature-unit");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteUnitLocalizationTemperatureUnit() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x0000002D, 0x00000000, mValue);
    }

private:
    chip::app::Clusters::UnitLocalization::TempUnit mValue;
};

/*----------------------------------------------------------------------------*\
| Cluster UserLabel                                                   | 0x0041 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * LabelList                                                         | 0x0000 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

class WriteUserLabelLabelList : public WriteAttribute
{
public:
    WriteUserLabelLabelList(CredentialIssuerCommands * credsIssuerConfig) :
        WriteAttribute("LabelList", credsIssuerConfig), mComplex(&mValue)
    {
        AddArgument("attr-name", "label-list");
        AddArgument("attr-value", &mComplex);
        WriteAttribute::AddArguments();
    }

    ~WriteUserLabelLabelList() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000041, 0x00000000, mValue);
    }

private:
    chip::app::DataModel::List<const chip::app::Clusters::UserLabel::Structs::LabelStruct::Type> mValue;
    TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::UserLabel::Structs::LabelStruct::Type>> mComplex;
};

/*----------------------------------------------------------------------------*\
| Cluster WakeOnLan                                                   | 0x0503 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * WakeOnLanMacAddress                                               | 0x0000 |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*\
| Cluster WiFiNetworkDiagnostics                                      | 0x0036 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * ResetCounts                                                       |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Bssid                                                             | 0x0000 |
| * SecurityType                                                      | 0x0001 |
| * WiFiVersion                                                       | 0x0002 |
| * ChannelNumber                                                     | 0x0003 |
| * Rssi                                                              | 0x0004 |
| * BeaconLostCount                                                   | 0x0005 |
| * BeaconRxCount                                                     | 0x0006 |
| * PacketMulticastRxCount                                            | 0x0007 |
| * PacketMulticastTxCount                                            | 0x0008 |
| * PacketUnicastRxCount                                              | 0x0009 |
| * PacketUnicastTxCount                                              | 0x000A |
| * CurrentMaxRate                                                    | 0x000B |
| * OverrunCount                                                      | 0x000C |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
| * Disconnection                                                     | 0x0000 |
| * AssociationFailure                                                | 0x0001 |
| * ConnectionStatus                                                  | 0x0002 |
\*----------------------------------------------------------------------------*/

/*
 * Command ResetCounts
 */
class WiFiNetworkDiagnosticsResetCounts : public ClusterCommand
{
public:
    WiFiNetworkDiagnosticsResetCounts(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("reset-counts", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000036) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000036, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::WiFiNetworkDiagnostics::Commands::ResetCounts::Type mRequest;
};

/*----------------------------------------------------------------------------*\
| Cluster WindowCovering                                              | 0x0102 |
|------------------------------------------------------------------------------|
| Commands:                                                           |        |
| * DownOrClose                                                       |   0x01 |
| * GoToLiftPercentage                                                |   0x05 |
| * GoToLiftValue                                                     |   0x04 |
| * GoToTiltPercentage                                                |   0x08 |
| * GoToTiltValue                                                     |   0x07 |
| * StopMotion                                                        |   0x02 |
| * UpOrOpen                                                          |   0x00 |
|------------------------------------------------------------------------------|
| Attributes:                                                         |        |
| * Type                                                              | 0x0000 |
| * CurrentPositionLift                                               | 0x0003 |
| * CurrentPositionTilt                                               | 0x0004 |
| * ConfigStatus                                                      | 0x0007 |
| * CurrentPositionLiftPercentage                                     | 0x0008 |
| * CurrentPositionTiltPercentage                                     | 0x0009 |
| * OperationalStatus                                                 | 0x000A |
| * TargetPositionLiftPercent100ths                                   | 0x000B |
| * TargetPositionTiltPercent100ths                                   | 0x000C |
| * EndProductType                                                    | 0x000D |
| * CurrentPositionLiftPercent100ths                                  | 0x000E |
| * CurrentPositionTiltPercent100ths                                  | 0x000F |
| * InstalledOpenLimitLift                                            | 0x0010 |
| * InstalledClosedLimitLift                                          | 0x0011 |
| * InstalledOpenLimitTilt                                            | 0x0012 |
| * InstalledClosedLimitTilt                                          | 0x0013 |
| * Mode                                                              | 0x0017 |
| * SafetyStatus                                                      | 0x001A |
| * ServerGeneratedCommandList                                        | 0xFFF8 |
| * ClientGeneratedCommandList                                        | 0xFFF9 |
| * AttributeList                                                     | 0xFFFB |
| * FeatureMap                                                        | 0xFFFC |
| * ClusterRevision                                                   | 0xFFFD |
|------------------------------------------------------------------------------|
| Events:                                                             |        |
\*----------------------------------------------------------------------------*/

/*
 * Command DownOrClose
 */
class WindowCoveringDownOrClose : public ClusterCommand
{
public:
    WindowCoveringDownOrClose(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("down-or-close", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000102) command (0x00000001) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000102, 0x00000001, mRequest);
    }

private:
    chip::app::Clusters::WindowCovering::Commands::DownOrClose::Type mRequest;
};

/*
 * Command GoToLiftPercentage
 */
class WindowCoveringGoToLiftPercentage : public ClusterCommand
{
public:
    WindowCoveringGoToLiftPercentage(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("go-to-lift-percentage", credsIssuerConfig)
    {
        AddArgument("LiftPercentageValue", 0, UINT8_MAX, &mRequest.liftPercentageValue);
        AddArgument("LiftPercent100thsValue", 0, UINT16_MAX, &mRequest.liftPercent100thsValue);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000102) command (0x00000005) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000102, 0x00000005, mRequest);
    }

private:
    chip::app::Clusters::WindowCovering::Commands::GoToLiftPercentage::Type mRequest;
};

/*
 * Command GoToLiftValue
 */
class WindowCoveringGoToLiftValue : public ClusterCommand
{
public:
    WindowCoveringGoToLiftValue(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("go-to-lift-value", credsIssuerConfig)
    {
        AddArgument("LiftValue", 0, UINT16_MAX, &mRequest.liftValue);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000102) command (0x00000004) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000102, 0x00000004, mRequest);
    }

private:
    chip::app::Clusters::WindowCovering::Commands::GoToLiftValue::Type mRequest;
};

/*
 * Command GoToTiltPercentage
 */
class WindowCoveringGoToTiltPercentage : public ClusterCommand
{
public:
    WindowCoveringGoToTiltPercentage(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("go-to-tilt-percentage", credsIssuerConfig)
    {
        AddArgument("TiltPercentageValue", 0, UINT8_MAX, &mRequest.tiltPercentageValue);
        AddArgument("TiltPercent100thsValue", 0, UINT16_MAX, &mRequest.tiltPercent100thsValue);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000102) command (0x00000008) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000102, 0x00000008, mRequest);
    }

private:
    chip::app::Clusters::WindowCovering::Commands::GoToTiltPercentage::Type mRequest;
};

/*
 * Command GoToTiltValue
 */
class WindowCoveringGoToTiltValue : public ClusterCommand
{
public:
    WindowCoveringGoToTiltValue(CredentialIssuerCommands * credsIssuerConfig) :
        ClusterCommand("go-to-tilt-value", credsIssuerConfig)
    {
        AddArgument("TiltValue", 0, UINT16_MAX, &mRequest.tiltValue);
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000102) command (0x00000007) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000102, 0x00000007, mRequest);
    }

private:
    chip::app::Clusters::WindowCovering::Commands::GoToTiltValue::Type mRequest;
};

/*
 * Command StopMotion
 */
class WindowCoveringStopMotion : public ClusterCommand
{
public:
    WindowCoveringStopMotion(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop-motion", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000102) command (0x00000002) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000102, 0x00000002, mRequest);
    }

private:
    chip::app::Clusters::WindowCovering::Commands::StopMotion::Type mRequest;
};

/*
 * Command UpOrOpen
 */
class WindowCoveringUpOrOpen : public ClusterCommand
{
public:
    WindowCoveringUpOrOpen(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("up-or-open", credsIssuerConfig)
    {
        ClusterCommand::AddArguments();
    }

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        ChipLogProgress(chipTool, "Sending cluster (0x00000102) command (0x00000000) on endpoint %" PRIu16, endpointId);

        return ClusterCommand::SendCommand(device, endpointId, 0x00000102, 0x00000000, mRequest);
    }

private:
    chip::app::Clusters::WindowCovering::Commands::UpOrOpen::Type mRequest;
};

class WriteWindowCoveringMode : public WriteAttribute
{
public:
    WriteWindowCoveringMode(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Mode", credsIssuerConfig)
    {
        AddArgument("attr-name", "mode");
        AddArgument("attr-value", 0, UINT8_MAX, &mValue);
        WriteAttribute::AddArguments();
    }

    ~WriteWindowCoveringMode() {}

    CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
    {
        return WriteAttribute::SendCommand(device, endpointId, 0x00000102, 0x00000017, mValue);
    }

private:
    uint8_t mValue;
};

/*----------------------------------------------------------------------------*\
| Register all Clusters commands                                               |
\*----------------------------------------------------------------------------*/
void registerClusterAccessControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::AccessControl;

    const char * clusterName = "AccessControl";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                         //
        make_unique<ReadAttribute>(Id, "acl", Attributes::Acl::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "extension", Attributes::Extension::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<WriteAccessControlAcl>(credsIssuerConfig),                                                  //
        make_unique<WriteAccessControlExtension>(credsIssuerConfig),                                            //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeAttribute>(Id, "acl", Attributes::Acl::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "extension", Attributes::Extension::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                                        //
        make_unique<ReadEvent>(Id, "access-control-entry-changed", Events::AccessControlEntryChanged::Id, credsIssuerConfig), //
        make_unique<ReadEvent>(Id, "access-control-extension-changed", Events::AccessControlExtensionChanged::Id,
                               credsIssuerConfig),          //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "access-control-entry-changed", Events::AccessControlEntryChanged::Id,
                                    credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "access-control-extension-changed", Events::AccessControlExtensionChanged::Id,
                                    credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterAccountLogin(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::AccountLogin;

    const char * clusterName = "AccountLogin";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),             //
        make_unique<AccountLoginGetSetupPINRequest>(credsIssuerConfig), //
        make_unique<AccountLoginLoginRequest>(credsIssuerConfig),       //
        make_unique<AccountLoginLogoutRequest>(credsIssuerConfig),      //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterAdministratorCommissioning(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::AdministratorCommissioning;

    const char * clusterName = "AdministratorCommissioning";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                                     //
        make_unique<AdministratorCommissioningOpenBasicCommissioningWindow>(credsIssuerConfig), //
        make_unique<AdministratorCommissioningOpenCommissioningWindow>(credsIssuerConfig),      //
        make_unique<AdministratorCommissioningRevokeCommissioning>(credsIssuerConfig),          //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<ReadAttribute>(Id, "window-status", Attributes::WindowStatus::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "admin-fabric-index", Attributes::AdminFabricIndex::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "admin-vendor-id", Attributes::AdminVendorId::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                  //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),         //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                             //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeAttribute>(Id, "window-status", Attributes::WindowStatus::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "admin-fabric-index", Attributes::AdminFabricIndex::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "admin-vendor-id", Attributes::AdminVendorId::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterApplicationBasic(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ApplicationBasic;

    const char * clusterName = "ApplicationBasic";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                            //
        make_unique<ReadAttribute>(Id, "vendor-name", Attributes::VendorName::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "vendor-id", Attributes::VendorId::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "application-name", Attributes::ApplicationName::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "product-id", Attributes::ProductId::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "application-app", Attributes::ApplicationApp::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "application-status", Attributes::ApplicationStatus::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "application-version", Attributes::ApplicationVersion::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "allowed-vendor-list", Attributes::AllowedVendorList::Id, credsIssuerConfig),  //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),            //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                            //
        make_unique<SubscribeAttribute>(Id, "vendor-name", Attributes::VendorName::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "vendor-id", Attributes::VendorId::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "application-name", Attributes::ApplicationName::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "product-id", Attributes::ProductId::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "application-app", Attributes::ApplicationApp::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "application-status", Attributes::ApplicationStatus::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "application-version", Attributes::ApplicationVersion::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "allowed-vendor-list", Attributes::AllowedVendorList::Id, credsIssuerConfig),  //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterApplicationLauncher(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ApplicationLauncher;

    const char * clusterName = "ApplicationLauncher";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                  //
        make_unique<ApplicationLauncherHideAppRequest>(credsIssuerConfig),   //
        make_unique<ApplicationLauncherLaunchAppRequest>(credsIssuerConfig), //
        make_unique<ApplicationLauncherStopAppRequest>(credsIssuerConfig),   //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                       //
        make_unique<ReadAttribute>(Id, "application-launcher-list", Attributes::ApplicationLauncherList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "application-launcher-app", Attributes::ApplicationLauncherApp::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<WriteApplicationLauncherApplicationLauncherApp>(credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeAttribute>(Id, "application-launcher-list", Attributes::ApplicationLauncherList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "application-launcher-app", Attributes::ApplicationLauncherApp::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterAudioOutput(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::AudioOutput;

    const char * clusterName = "AudioOutput";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),             //
        make_unique<AudioOutputRenameOutputRequest>(credsIssuerConfig), //
        make_unique<AudioOutputSelectOutputRequest>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                             //
        make_unique<ReadAttribute>(Id, "audio-output-list", Attributes::AudioOutputList::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "current-audio-output", Attributes::CurrentAudioOutput::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                      //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),             //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                             //
        make_unique<SubscribeAttribute>(Id, "audio-output-list", Attributes::AudioOutputList::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "current-audio-output", Attributes::CurrentAudioOutput::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterBarrierControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::BarrierControl;

    const char * clusterName = "BarrierControl";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                      //
        make_unique<BarrierControlBarrierControlGoToPercent>(credsIssuerConfig), //
        make_unique<BarrierControlBarrierControlStop>(credsIssuerConfig),        //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<ReadAttribute>(Id, "barrier-moving-state", Attributes::BarrierMovingState::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "barrier-safety-status", Attributes::BarrierSafetyStatus::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "barrier-capabilities", Attributes::BarrierCapabilities::Id, credsIssuerConfig),  //
        make_unique<ReadAttribute>(Id, "barrier-position", Attributes::BarrierPosition::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),               //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                                   //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<SubscribeAttribute>(Id, "barrier-moving-state", Attributes::BarrierMovingState::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "barrier-safety-status", Attributes::BarrierSafetyStatus::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "barrier-capabilities", Attributes::BarrierCapabilities::Id, credsIssuerConfig),  //
        make_unique<SubscribeAttribute>(Id, "barrier-position", Attributes::BarrierPosition::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterBasic(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Basic;

    const char * clusterName = "Basic";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                   //
        make_unique<ReadAttribute>(Id, "data-model-revision", Attributes::DataModelRevision::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "vendor-name", Attributes::VendorName::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "vendor-id", Attributes::VendorID::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "product-name", Attributes::ProductName::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "product-id", Attributes::ProductID::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "node-label", Attributes::NodeLabel::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "location", Attributes::Location::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "hardware-version", Attributes::HardwareVersion::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "hardware-version-string", Attributes::HardwareVersionString::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "software-version", Attributes::SoftwareVersion::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "software-version-string", Attributes::SoftwareVersionString::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "manufacturing-date", Attributes::ManufacturingDate::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "part-number", Attributes::PartNumber::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "product-url", Attributes::ProductURL::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "product-label", Attributes::ProductLabel::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "serial-number", Attributes::SerialNumber::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "local-config-disabled", Attributes::LocalConfigDisabled::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "reachable", Attributes::Reachable::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "unique-id", Attributes::UniqueID::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                            //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                   //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                                       //
        make_unique<WriteBasicNodeLabel>(credsIssuerConfig),                                                                      //
        make_unique<WriteBasicLocation>(credsIssuerConfig),                                                                       //
        make_unique<WriteBasicLocalConfigDisabled>(credsIssuerConfig),                                                            //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                   //
        make_unique<SubscribeAttribute>(Id, "data-model-revision", Attributes::DataModelRevision::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "vendor-name", Attributes::VendorName::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "vendor-id", Attributes::VendorID::Id, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, "product-name", Attributes::ProductName::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "product-id", Attributes::ProductID::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "node-label", Attributes::NodeLabel::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "location", Attributes::Location::Id, credsIssuerConfig),                             //
        make_unique<SubscribeAttribute>(Id, "hardware-version", Attributes::HardwareVersion::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "hardware-version-string", Attributes::HardwareVersionString::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "software-version", Attributes::SoftwareVersion::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "software-version-string", Attributes::SoftwareVersionString::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "manufacturing-date", Attributes::ManufacturingDate::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "part-number", Attributes::PartNumber::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "product-url", Attributes::ProductURL::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "product-label", Attributes::ProductLabel::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "serial-number", Attributes::SerialNumber::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "local-config-disabled", Attributes::LocalConfigDisabled::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "reachable", Attributes::Reachable::Id, credsIssuerConfig),                           //
        make_unique<SubscribeAttribute>(Id, "unique-id", Attributes::UniqueID::Id, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                         //
        make_unique<ReadEvent>(Id, "start-up", Events::StartUp::Id, credsIssuerConfig),                        //
        make_unique<ReadEvent>(Id, "shut-down", Events::ShutDown::Id, credsIssuerConfig),                      //
        make_unique<ReadEvent>(Id, "leave", Events::Leave::Id, credsIssuerConfig),                             //
        make_unique<ReadEvent>(Id, "reachable-changed", Events::ReachableChanged::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                    //
        make_unique<SubscribeEvent>(Id, "start-up", Events::StartUp::Id, credsIssuerConfig),                   //
        make_unique<SubscribeEvent>(Id, "shut-down", Events::ShutDown::Id, credsIssuerConfig),                 //
        make_unique<SubscribeEvent>(Id, "leave", Events::Leave::Id, credsIssuerConfig),                        //
        make_unique<SubscribeEvent>(Id, "reachable-changed", Events::ReachableChanged::Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterBinaryInputBasic(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::BinaryInputBasic;

    const char * clusterName = "BinaryInputBasic";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<ReadAttribute>(Id, "out-of-service", Attributes::OutOfService::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "present-value", Attributes::PresentValue::Id, credsIssuerConfig),  //
        make_unique<ReadAttribute>(Id, "status-flags", Attributes::StatusFlags::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<WriteBinaryInputBasicOutOfService>(credsIssuerConfig),                                      //
        make_unique<WriteBinaryInputBasicPresentValue>(credsIssuerConfig),                                      //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeAttribute>(Id, "out-of-service", Attributes::OutOfService::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "present-value", Attributes::PresentValue::Id, credsIssuerConfig),  //
        make_unique<SubscribeAttribute>(Id, "status-flags", Attributes::StatusFlags::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterBinding(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Binding;

    const char * clusterName = "Binding";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                              //
        make_unique<ReadAttribute>(Id, "binding-list", Attributes::BindingList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<WriteBindingBindingList>(credsIssuerConfig),                                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeAttribute>(Id, "binding-list", Attributes::BindingList::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterBooleanState(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::BooleanState;

    const char * clusterName = "BooleanState";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                            //
        make_unique<ReadAttribute>(Id, "state-value", Attributes::StateValue::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeAttribute>(Id, "state-value", Attributes::StateValue::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                               //
        make_unique<ReadEvent>(Id, "state-change", Events::StateChange::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                          //
        make_unique<SubscribeEvent>(Id, "state-change", Events::StateChange::Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterBridgedActions(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::BridgedActions;

    const char * clusterName = "BridgedActions";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                        //
        make_unique<BridgedActionsDisableAction>(credsIssuerConfig),               //
        make_unique<BridgedActionsDisableActionWithDuration>(credsIssuerConfig),   //
        make_unique<BridgedActionsEnableAction>(credsIssuerConfig),                //
        make_unique<BridgedActionsEnableActionWithDuration>(credsIssuerConfig),    //
        make_unique<BridgedActionsInstantAction>(credsIssuerConfig),               //
        make_unique<BridgedActionsInstantActionWithTransition>(credsIssuerConfig), //
        make_unique<BridgedActionsPauseAction>(credsIssuerConfig),                 //
        make_unique<BridgedActionsPauseActionWithDuration>(credsIssuerConfig),     //
        make_unique<BridgedActionsResumeAction>(credsIssuerConfig),                //
        make_unique<BridgedActionsStartAction>(credsIssuerConfig),                 //
        make_unique<BridgedActionsStartActionWithDuration>(credsIssuerConfig),     //
        make_unique<BridgedActionsStopAction>(credsIssuerConfig),                  //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                //
        make_unique<ReadAttribute>(Id, "action-list", Attributes::ActionList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "endpoint-list", Attributes::EndpointList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "setup-url", Attributes::SetupUrl::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeAttribute>(Id, "action-list", Attributes::ActionList::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "endpoint-list", Attributes::EndpointList::Id, credsIssuerConfig),  //
        make_unique<SubscribeAttribute>(Id, "setup-url", Attributes::SetupUrl::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                 //
        make_unique<ReadEvent>(Id, "state-changed", Events::StateChanged::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "action-failed", Events::ActionFailed::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                            //
        make_unique<SubscribeEvent>(Id, "state-changed", Events::StateChanged::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "action-failed", Events::ActionFailed::Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterBridgedDeviceBasic(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::BridgedDeviceBasic;

    const char * clusterName = "BridgedDeviceBasic";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                   //
        make_unique<ReadAttribute>(Id, "vendor-name", Attributes::VendorName::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "vendor-id", Attributes::VendorID::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "product-name", Attributes::ProductName::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "node-label", Attributes::NodeLabel::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "hardware-version", Attributes::HardwareVersion::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "hardware-version-string", Attributes::HardwareVersionString::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "software-version", Attributes::SoftwareVersion::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "software-version-string", Attributes::SoftwareVersionString::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "manufacturing-date", Attributes::ManufacturingDate::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "part-number", Attributes::PartNumber::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "product-url", Attributes::ProductURL::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "product-label", Attributes::ProductLabel::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "serial-number", Attributes::SerialNumber::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "reachable", Attributes::Reachable::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                            //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                   //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                                       //
        make_unique<WriteBridgedDeviceBasicNodeLabel>(credsIssuerConfig),                                                         //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                   //
        make_unique<SubscribeAttribute>(Id, "vendor-name", Attributes::VendorName::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "vendor-id", Attributes::VendorID::Id, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, "product-name", Attributes::ProductName::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "node-label", Attributes::NodeLabel::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "hardware-version", Attributes::HardwareVersion::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "hardware-version-string", Attributes::HardwareVersionString::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "software-version", Attributes::SoftwareVersion::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "software-version-string", Attributes::SoftwareVersionString::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "manufacturing-date", Attributes::ManufacturingDate::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "part-number", Attributes::PartNumber::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "product-url", Attributes::ProductURL::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "product-label", Attributes::ProductLabel::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "serial-number", Attributes::SerialNumber::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "reachable", Attributes::Reachable::Id, credsIssuerConfig),                           //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                         //
        make_unique<ReadEvent>(Id, "start-up", Events::StartUp::Id, credsIssuerConfig),                        //
        make_unique<ReadEvent>(Id, "shut-down", Events::ShutDown::Id, credsIssuerConfig),                      //
        make_unique<ReadEvent>(Id, "leave", Events::Leave::Id, credsIssuerConfig),                             //
        make_unique<ReadEvent>(Id, "reachable-changed", Events::ReachableChanged::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                    //
        make_unique<SubscribeEvent>(Id, "start-up", Events::StartUp::Id, credsIssuerConfig),                   //
        make_unique<SubscribeEvent>(Id, "shut-down", Events::ShutDown::Id, credsIssuerConfig),                 //
        make_unique<SubscribeEvent>(Id, "leave", Events::Leave::Id, credsIssuerConfig),                        //
        make_unique<SubscribeEvent>(Id, "reachable-changed", Events::ReachableChanged::Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterChannel(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Channel;

    const char * clusterName = "Channel";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                  //
        make_unique<ChannelChangeChannelByNumberRequest>(credsIssuerConfig), //
        make_unique<ChannelChangeChannelRequest>(credsIssuerConfig),         //
        make_unique<ChannelSkipChannelRequest>(credsIssuerConfig),           //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                    //
        make_unique<ReadAttribute>(Id, "channel-list", Attributes::ChannelList::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "channel-lineup", Attributes::ChannelLineup::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "current-channel", Attributes::CurrentChannel::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                             //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),    //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                        //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                    //
        make_unique<SubscribeAttribute>(Id, "channel-list", Attributes::ChannelList::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "channel-lineup", Attributes::ChannelLineup::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "current-channel", Attributes::CurrentChannel::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterColorControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ColorControl;

    const char * clusterName = "ColorControl";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                         //
        make_unique<ColorControlColorLoopSet>(credsIssuerConfig),                   //
        make_unique<ColorControlEnhancedMoveHue>(credsIssuerConfig),                //
        make_unique<ColorControlEnhancedMoveToHue>(credsIssuerConfig),              //
        make_unique<ColorControlEnhancedMoveToHueAndSaturation>(credsIssuerConfig), //
        make_unique<ColorControlEnhancedStepHue>(credsIssuerConfig),                //
        make_unique<ColorControlMoveColor>(credsIssuerConfig),                      //
        make_unique<ColorControlMoveColorTemperature>(credsIssuerConfig),           //
        make_unique<ColorControlMoveHue>(credsIssuerConfig),                        //
        make_unique<ColorControlMoveSaturation>(credsIssuerConfig),                 //
        make_unique<ColorControlMoveToColor>(credsIssuerConfig),                    //
        make_unique<ColorControlMoveToColorTemperature>(credsIssuerConfig),         //
        make_unique<ColorControlMoveToHue>(credsIssuerConfig),                      //
        make_unique<ColorControlMoveToHueAndSaturation>(credsIssuerConfig),         //
        make_unique<ColorControlMoveToSaturation>(credsIssuerConfig),               //
        make_unique<ColorControlStepColor>(credsIssuerConfig),                      //
        make_unique<ColorControlStepColorTemperature>(credsIssuerConfig),           //
        make_unique<ColorControlStepHue>(credsIssuerConfig),                        //
        make_unique<ColorControlStepSaturation>(credsIssuerConfig),                 //
        make_unique<ColorControlStopMoveStep>(credsIssuerConfig),                   //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "current-hue", Attributes::CurrentHue::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "current-saturation", Attributes::CurrentSaturation::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "remaining-time", Attributes::RemainingTime::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "current-x", Attributes::CurrentX::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "current-y", Attributes::CurrentY::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "drift-compensation", Attributes::DriftCompensation::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "compensation-text", Attributes::CompensationText::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "color-temperature", Attributes::ColorTemperature::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "color-mode", Attributes::ColorMode::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "color-control-options", Attributes::ColorControlOptions::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "number-of-primaries", Attributes::NumberOfPrimaries::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "primary1x", Attributes::Primary1X::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "primary1y", Attributes::Primary1Y::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "primary1intensity", Attributes::Primary1Intensity::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "primary2x", Attributes::Primary2X::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "primary2y", Attributes::Primary2Y::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "primary2intensity", Attributes::Primary2Intensity::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "primary3x", Attributes::Primary3X::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "primary3y", Attributes::Primary3Y::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "primary3intensity", Attributes::Primary3Intensity::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "primary4x", Attributes::Primary4X::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "primary4y", Attributes::Primary4Y::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "primary4intensity", Attributes::Primary4Intensity::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "primary5x", Attributes::Primary5X::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "primary5y", Attributes::Primary5Y::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "primary5intensity", Attributes::Primary5Intensity::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "primary6x", Attributes::Primary6X::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "primary6y", Attributes::Primary6Y::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "primary6intensity", Attributes::Primary6Intensity::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "white-point-x", Attributes::WhitePointX::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "white-point-y", Attributes::WhitePointY::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "color-point-rx", Attributes::ColorPointRX::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "color-point-ry", Attributes::ColorPointRY::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "color-point-rintensity", Attributes::ColorPointRIntensity::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "color-point-gx", Attributes::ColorPointGX::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "color-point-gy", Attributes::ColorPointGY::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "color-point-gintensity", Attributes::ColorPointGIntensity::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "color-point-bx", Attributes::ColorPointBX::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "color-point-by", Attributes::ColorPointBY::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "color-point-bintensity", Attributes::ColorPointBIntensity::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "enhanced-current-hue", Attributes::EnhancedCurrentHue::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "enhanced-color-mode", Attributes::EnhancedColorMode::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "color-loop-active", Attributes::ColorLoopActive::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "color-loop-direction", Attributes::ColorLoopDirection::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "color-loop-time", Attributes::ColorLoopTime::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "color-loop-start-enhanced-hue", Attributes::ColorLoopStartEnhancedHue::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "color-loop-stored-enhanced-hue", Attributes::ColorLoopStoredEnhancedHue::Id,
                                   credsIssuerConfig),                                                                      //
        make_unique<ReadAttribute>(Id, "color-capabilities", Attributes::ColorCapabilities::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "color-temp-physical-min", Attributes::ColorTempPhysicalMin::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "color-temp-physical-max", Attributes::ColorTempPhysicalMax::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "couple-color-temp-to-level-min-mireds", Attributes::CoupleColorTempToLevelMinMireds::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "start-up-color-temperature-mireds", Attributes::StartUpColorTemperatureMireds::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                 //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                                     //
        make_unique<WriteColorControlColorControlOptions>(credsIssuerConfig),                                                   //
        make_unique<WriteColorControlWhitePointX>(credsIssuerConfig),                                                           //
        make_unique<WriteColorControlWhitePointY>(credsIssuerConfig),                                                           //
        make_unique<WriteColorControlColorPointRX>(credsIssuerConfig),                                                          //
        make_unique<WriteColorControlColorPointRY>(credsIssuerConfig),                                                          //
        make_unique<WriteColorControlColorPointRIntensity>(credsIssuerConfig),                                                  //
        make_unique<WriteColorControlColorPointGX>(credsIssuerConfig),                                                          //
        make_unique<WriteColorControlColorPointGY>(credsIssuerConfig),                                                          //
        make_unique<WriteColorControlColorPointGIntensity>(credsIssuerConfig),                                                  //
        make_unique<WriteColorControlColorPointBX>(credsIssuerConfig),                                                          //
        make_unique<WriteColorControlColorPointBY>(credsIssuerConfig),                                                          //
        make_unique<WriteColorControlColorPointBIntensity>(credsIssuerConfig),                                                  //
        make_unique<WriteColorControlStartUpColorTemperatureMireds>(credsIssuerConfig),                                         //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "current-hue", Attributes::CurrentHue::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "current-saturation", Attributes::CurrentSaturation::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "remaining-time", Attributes::RemainingTime::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "current-x", Attributes::CurrentX::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "current-y", Attributes::CurrentY::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "drift-compensation", Attributes::DriftCompensation::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "compensation-text", Attributes::CompensationText::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "color-temperature", Attributes::ColorTemperature::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "color-mode", Attributes::ColorMode::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "color-control-options", Attributes::ColorControlOptions::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "number-of-primaries", Attributes::NumberOfPrimaries::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "primary1x", Attributes::Primary1X::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary1y", Attributes::Primary1Y::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary1intensity", Attributes::Primary1Intensity::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "primary2x", Attributes::Primary2X::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary2y", Attributes::Primary2Y::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary2intensity", Attributes::Primary2Intensity::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "primary3x", Attributes::Primary3X::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary3y", Attributes::Primary3Y::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary3intensity", Attributes::Primary3Intensity::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "primary4x", Attributes::Primary4X::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary4y", Attributes::Primary4Y::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary4intensity", Attributes::Primary4Intensity::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "primary5x", Attributes::Primary5X::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary5y", Attributes::Primary5Y::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary5intensity", Attributes::Primary5Intensity::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "primary6x", Attributes::Primary6X::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary6y", Attributes::Primary6Y::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "primary6intensity", Attributes::Primary6Intensity::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "white-point-x", Attributes::WhitePointX::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "white-point-y", Attributes::WhitePointY::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "color-point-rx", Attributes::ColorPointRX::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "color-point-ry", Attributes::ColorPointRY::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "color-point-rintensity", Attributes::ColorPointRIntensity::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "color-point-gx", Attributes::ColorPointGX::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "color-point-gy", Attributes::ColorPointGY::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "color-point-gintensity", Attributes::ColorPointGIntensity::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "color-point-bx", Attributes::ColorPointBX::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "color-point-by", Attributes::ColorPointBY::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "color-point-bintensity", Attributes::ColorPointBIntensity::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "enhanced-current-hue", Attributes::EnhancedCurrentHue::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "enhanced-color-mode", Attributes::EnhancedColorMode::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "color-loop-active", Attributes::ColorLoopActive::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "color-loop-direction", Attributes::ColorLoopDirection::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "color-loop-time", Attributes::ColorLoopTime::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "color-loop-start-enhanced-hue", Attributes::ColorLoopStartEnhancedHue::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "color-loop-stored-enhanced-hue", Attributes::ColorLoopStoredEnhancedHue::Id,
                                        credsIssuerConfig),                                                                      //
        make_unique<SubscribeAttribute>(Id, "color-capabilities", Attributes::ColorCapabilities::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "color-temp-physical-min", Attributes::ColorTempPhysicalMin::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "color-temp-physical-max", Attributes::ColorTempPhysicalMax::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "couple-color-temp-to-level-min-mireds",
                                        Attributes::CoupleColorTempToLevelMinMireds::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "start-up-color-temperature-mireds", Attributes::StartUpColorTemperatureMireds::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterContentLauncher(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ContentLauncher;

    const char * clusterName = "ContentLauncher";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                  //
        make_unique<ContentLauncherLaunchContentRequest>(credsIssuerConfig), //
        make_unique<ContentLauncherLaunchURLRequest>(credsIssuerConfig),     //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<ReadAttribute>(Id, "accept-header-list", Attributes::AcceptHeaderList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "supported-streaming-protocols", Attributes::SupportedStreamingProtocols::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                  //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),         //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                             //
        make_unique<WriteContentLauncherSupportedStreamingProtocols>(credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeAttribute>(Id, "accept-header-list", Attributes::AcceptHeaderList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "supported-streaming-protocols", Attributes::SupportedStreamingProtocols::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterDescriptor(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Descriptor;

    const char * clusterName = "Descriptor";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                            //
        make_unique<ReadAttribute>(Id, "device-list", Attributes::DeviceList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-list", Attributes::ServerList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-list", Attributes::ClientList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "parts-list", Attributes::PartsList::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeAttribute>(Id, "device-list", Attributes::DeviceList::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "server-list", Attributes::ServerList::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "client-list", Attributes::ClientList::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "parts-list", Attributes::PartsList::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterDiagnosticLogs(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::DiagnosticLogs;

    const char * clusterName = "DiagnosticLogs";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                //
        make_unique<DiagnosticLogsRetrieveLogsRequest>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                      //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                             //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                      //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterDoorLock(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::DoorLock;

    const char * clusterName = "DoorLock";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),           //
        make_unique<DoorLockClearCredential>(credsIssuerConfig),      //
        make_unique<DoorLockClearUser>(credsIssuerConfig),            //
        make_unique<DoorLockClearWeekDaySchedule>(credsIssuerConfig), //
        make_unique<DoorLockClearYearDaySchedule>(credsIssuerConfig), //
        make_unique<DoorLockGetCredentialStatus>(credsIssuerConfig),  //
        make_unique<DoorLockGetUser>(credsIssuerConfig),              //
        make_unique<DoorLockGetWeekDaySchedule>(credsIssuerConfig),   //
        make_unique<DoorLockGetYearDaySchedule>(credsIssuerConfig),   //
        make_unique<DoorLockLockDoor>(credsIssuerConfig),             //
        make_unique<DoorLockSetCredential>(credsIssuerConfig),        //
        make_unique<DoorLockSetUser>(credsIssuerConfig),              //
        make_unique<DoorLockSetWeekDaySchedule>(credsIssuerConfig),   //
        make_unique<DoorLockSetYearDaySchedule>(credsIssuerConfig),   //
        make_unique<DoorLockUnlockDoor>(credsIssuerConfig),           //
        make_unique<DoorLockUnlockWithTimeout>(credsIssuerConfig),    //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                      //
        make_unique<ReadAttribute>(Id, "lock-state", Attributes::LockState::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "lock-type", Attributes::LockType::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "actuator-enabled", Attributes::ActuatorEnabled::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "door-state", Attributes::DoorState::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "number-of-total-users-supported", Attributes::NumberOfTotalUsersSupported::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "number-of-pinusers-supported", Attributes::NumberOfPINUsersSupported::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "number-of-rfidusers-supported", Attributes::NumberOfRFIDUsersSupported::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "number-of-week-day-schedules-supported-per-user",
                                   Attributes::NumberOfWeekDaySchedulesSupportedPerUser::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "number-of-year-day-schedules-supported-per-user",
                                   Attributes::NumberOfYearDaySchedulesSupportedPerUser::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "max-pincode-length", Attributes::MaxPINCodeLength::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "min-pincode-length", Attributes::MinPINCodeLength::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "max-rfidcode-length", Attributes::MaxRFIDCodeLength::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "min-rfidcode-length", Attributes::MinRFIDCodeLength::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "language", Attributes::Language::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "auto-relock-time", Attributes::AutoRelockTime::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "sound-volume", Attributes::SoundVolume::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "operating-mode", Attributes::OperatingMode::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "supported-operating-modes", Attributes::SupportedOperatingModes::Id, credsIssuerConfig),  //
        make_unique<ReadAttribute>(Id, "enable-one-touch-locking", Attributes::EnableOneTouchLocking::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "enable-privacy-mode-button", Attributes::EnablePrivacyModeButton::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "wrong-code-entry-limit", Attributes::WrongCodeEntryLimit::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                               //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),      //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                          //
        make_unique<WriteDoorLockLanguage>(credsIssuerConfig),                                                       //
        make_unique<WriteDoorLockAutoRelockTime>(credsIssuerConfig),                                                 //
        make_unique<WriteDoorLockSoundVolume>(credsIssuerConfig),                                                    //
        make_unique<WriteDoorLockOperatingMode>(credsIssuerConfig),                                                  //
        make_unique<WriteDoorLockEnableOneTouchLocking>(credsIssuerConfig),                                          //
        make_unique<WriteDoorLockEnablePrivacyModeButton>(credsIssuerConfig),                                        //
        make_unique<WriteDoorLockWrongCodeEntryLimit>(credsIssuerConfig),                                            //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                      //
        make_unique<SubscribeAttribute>(Id, "lock-state", Attributes::LockState::Id, credsIssuerConfig),             //
        make_unique<SubscribeAttribute>(Id, "lock-type", Attributes::LockType::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "actuator-enabled", Attributes::ActuatorEnabled::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "door-state", Attributes::DoorState::Id, credsIssuerConfig),             //
        make_unique<SubscribeAttribute>(Id, "number-of-total-users-supported", Attributes::NumberOfTotalUsersSupported::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-pinusers-supported", Attributes::NumberOfPINUsersSupported::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-rfidusers-supported", Attributes::NumberOfRFIDUsersSupported::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-week-day-schedules-supported-per-user",
                                        Attributes::NumberOfWeekDaySchedulesSupportedPerUser::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-year-day-schedules-supported-per-user",
                                        Attributes::NumberOfYearDaySchedulesSupportedPerUser::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "max-pincode-length", Attributes::MaxPINCodeLength::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "min-pincode-length", Attributes::MinPINCodeLength::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "max-rfidcode-length", Attributes::MaxRFIDCodeLength::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "min-rfidcode-length", Attributes::MinRFIDCodeLength::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "language", Attributes::Language::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "auto-relock-time", Attributes::AutoRelockTime::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "sound-volume", Attributes::SoundVolume::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "operating-mode", Attributes::OperatingMode::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "supported-operating-modes", Attributes::SupportedOperatingModes::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "enable-one-touch-locking", Attributes::EnableOneTouchLocking::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "enable-privacy-mode-button", Attributes::EnablePrivacyModeButton::Id,
                                        credsIssuerConfig),                                                                    //
        make_unique<SubscribeAttribute>(Id, "wrong-code-entry-limit", Attributes::WrongCodeEntryLimit::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                              //
        make_unique<ReadEvent>(Id, "door-lock-alarm", Events::DoorLockAlarm::Id, credsIssuerConfig),                //
        make_unique<ReadEvent>(Id, "door-state-change", Events::DoorStateChange::Id, credsIssuerConfig),            //
        make_unique<ReadEvent>(Id, "lock-operation", Events::LockOperation::Id, credsIssuerConfig),                 //
        make_unique<ReadEvent>(Id, "lock-operation-error", Events::LockOperationError::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "lock-user-change", Events::LockUserChange::Id, credsIssuerConfig),              //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeEvent>(Id, "door-lock-alarm", Events::DoorLockAlarm::Id, credsIssuerConfig),           //
        make_unique<SubscribeEvent>(Id, "door-state-change", Events::DoorStateChange::Id, credsIssuerConfig),       //
        make_unique<SubscribeEvent>(Id, "lock-operation", Events::LockOperation::Id, credsIssuerConfig),            //
        make_unique<SubscribeEvent>(Id, "lock-operation-error", Events::LockOperationError::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "lock-user-change", Events::LockUserChange::Id, credsIssuerConfig),         //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterElectricalMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ElectricalMeasurement;

    const char * clusterName = "ElectricalMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<ReadAttribute>(Id, "measurement-type", Attributes::MeasurementType::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "total-active-power", Attributes::TotalActivePower::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "rms-voltage", Attributes::RmsVoltage::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "rms-voltage-min", Attributes::RmsVoltageMin::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "rms-voltage-max", Attributes::RmsVoltageMax::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "rms-current", Attributes::RmsCurrent::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "rms-current-min", Attributes::RmsCurrentMin::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "rms-current-max", Attributes::RmsCurrentMax::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "active-power", Attributes::ActivePower::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "active-power-min", Attributes::ActivePowerMin::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "active-power-max", Attributes::ActivePowerMax::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                  //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),         //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                             //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeAttribute>(Id, "measurement-type", Attributes::MeasurementType::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "total-active-power", Attributes::TotalActivePower::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rms-voltage", Attributes::RmsVoltage::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "rms-voltage-min", Attributes::RmsVoltageMin::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "rms-voltage-max", Attributes::RmsVoltageMax::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "rms-current", Attributes::RmsCurrent::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "rms-current-min", Attributes::RmsCurrentMin::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "rms-current-max", Attributes::RmsCurrentMax::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "active-power", Attributes::ActivePower::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "active-power-min", Attributes::ActivePowerMin::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "active-power-max", Attributes::ActivePowerMax::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterEthernetNetworkDiagnostics(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::EthernetNetworkDiagnostics;

    const char * clusterName = "EthernetNetworkDiagnostics";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                    //
        make_unique<EthernetNetworkDiagnosticsResetCounts>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<ReadAttribute>(Id, "phyrate", Attributes::PHYRate::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "full-duplex", Attributes::FullDuplex::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "packet-rx-count", Attributes::PacketRxCount::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "packet-tx-count", Attributes::PacketTxCount::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "tx-err-count", Attributes::TxErrCount::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "collision-count", Attributes::CollisionCount::Id, credsIssuerConfig),  //
        make_unique<ReadAttribute>(Id, "overrun-count", Attributes::OverrunCount::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "carrier-detect", Attributes::CarrierDetect::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "time-since-reset", Attributes::TimeSinceReset::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                              //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),     //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<SubscribeAttribute>(Id, "phyrate", Attributes::PHYRate::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "full-duplex", Attributes::FullDuplex::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "packet-rx-count", Attributes::PacketRxCount::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "packet-tx-count", Attributes::PacketTxCount::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "tx-err-count", Attributes::TxErrCount::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "collision-count", Attributes::CollisionCount::Id, credsIssuerConfig),  //
        make_unique<SubscribeAttribute>(Id, "overrun-count", Attributes::OverrunCount::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "carrier-detect", Attributes::CarrierDetect::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "time-since-reset", Attributes::TimeSinceReset::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterFixedLabel(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::FixedLabel;

    const char * clusterName = "FixedLabel";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                          //
        make_unique<ReadAttribute>(Id, "label-list", Attributes::LabelList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeAttribute>(Id, "label-list", Attributes::LabelList::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterFlowMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::FlowMeasurement;

    const char * clusterName = "FlowMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                  //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),         //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                             //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterGeneralCommissioning(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::GeneralCommissioning;

    const char * clusterName = "GeneralCommissioning";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                        //
        make_unique<GeneralCommissioningArmFailSafe>(credsIssuerConfig),           //
        make_unique<GeneralCommissioningCommissioningComplete>(credsIssuerConfig), //
        make_unique<GeneralCommissioningSetRegulatoryConfig>(credsIssuerConfig),   //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "breadcrumb", Attributes::Breadcrumb::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "basic-commissioning-info", Attributes::BasicCommissioningInfo::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "regulatory-config", Attributes::RegulatoryConfig::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "location-capability", Attributes::LocationCapability::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<WriteGeneralCommissioningBreadcrumb>(credsIssuerConfig),                                    //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeAttribute>(Id, "breadcrumb", Attributes::Breadcrumb::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "basic-commissioning-info", Attributes::BasicCommissioningInfo::Id,
                                        credsIssuerConfig),                                                                //
        make_unique<SubscribeAttribute>(Id, "regulatory-config", Attributes::RegulatoryConfig::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "location-capability", Attributes::LocationCapability::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterGeneralDiagnostics(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::GeneralDiagnostics;

    const char * clusterName = "GeneralDiagnostics";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                   //
        make_unique<ReadAttribute>(Id, "network-interfaces", Attributes::NetworkInterfaces::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "reboot-count", Attributes::RebootCount::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "up-time", Attributes::UpTime::Id, credsIssuerConfig),                                //
        make_unique<ReadAttribute>(Id, "total-operational-hours", Attributes::TotalOperationalHours::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "boot-reasons", Attributes::BootReasons::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "active-hardware-faults", Attributes::ActiveHardwareFaults::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "active-radio-faults", Attributes::ActiveRadioFaults::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "active-network-faults", Attributes::ActiveNetworkFaults::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                            //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                   //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                                       //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                   //
        make_unique<SubscribeAttribute>(Id, "network-interfaces", Attributes::NetworkInterfaces::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "reboot-count", Attributes::RebootCount::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "up-time", Attributes::UpTime::Id, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, "total-operational-hours", Attributes::TotalOperationalHours::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "boot-reasons", Attributes::BootReasons::Id, credsIssuerConfig),                      //
        make_unique<SubscribeAttribute>(Id, "active-hardware-faults", Attributes::ActiveHardwareFaults::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "active-radio-faults", Attributes::ActiveRadioFaults::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "active-network-faults", Attributes::ActiveNetworkFaults::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                                //
        make_unique<ReadEvent>(Id, "hardware-fault-change", Events::HardwareFaultChange::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "radio-fault-change", Events::RadioFaultChange::Id, credsIssuerConfig),            //
        make_unique<ReadEvent>(Id, "network-fault-change", Events::NetworkFaultChange::Id, credsIssuerConfig),        //
        make_unique<ReadEvent>(Id, "boot-reason", Events::BootReason::Id, credsIssuerConfig),                         //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                           //
        make_unique<SubscribeEvent>(Id, "hardware-fault-change", Events::HardwareFaultChange::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "radio-fault-change", Events::RadioFaultChange::Id, credsIssuerConfig),       //
        make_unique<SubscribeEvent>(Id, "network-fault-change", Events::NetworkFaultChange::Id, credsIssuerConfig),   //
        make_unique<SubscribeEvent>(Id, "boot-reason", Events::BootReason::Id, credsIssuerConfig),                    //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterGroupKeyManagement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::GroupKeyManagement;

    const char * clusterName = "GroupKeyManagement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                     //
        make_unique<GroupKeyManagementKeySetRead>(credsIssuerConfig),           //
        make_unique<GroupKeyManagementKeySetReadAllIndices>(credsIssuerConfig), //
        make_unique<GroupKeyManagementKeySetRemove>(credsIssuerConfig),         //
        make_unique<GroupKeyManagementKeySetWrite>(credsIssuerConfig),          //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "group-key-map", Attributes::GroupKeyMap::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "group-table", Attributes::GroupTable::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "max-groups-per-fabric", Attributes::MaxGroupsPerFabric::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "max-group-keys-per-fabric", Attributes::MaxGroupKeysPerFabric::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                       //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),              //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                                  //
        make_unique<WriteGroupKeyManagementGroupKeyMap>(credsIssuerConfig),                                                  //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                              //
        make_unique<SubscribeAttribute>(Id, "group-key-map", Attributes::GroupKeyMap::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "group-table", Attributes::GroupTable::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "max-groups-per-fabric", Attributes::MaxGroupsPerFabric::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "max-group-keys-per-fabric", Attributes::MaxGroupKeysPerFabric::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterGroups(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Groups;

    const char * clusterName = "Groups";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),          //
        make_unique<GroupsAddGroup>(credsIssuerConfig),              //
        make_unique<GroupsAddGroupIfIdentifying>(credsIssuerConfig), //
        make_unique<GroupsGetGroupMembership>(credsIssuerConfig),    //
        make_unique<GroupsRemoveAllGroups>(credsIssuerConfig),       //
        make_unique<GroupsRemoveGroup>(credsIssuerConfig),           //
        make_unique<GroupsViewGroup>(credsIssuerConfig),             //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                              //
        make_unique<ReadAttribute>(Id, "name-support", Attributes::NameSupport::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeAttribute>(Id, "name-support", Attributes::NameSupport::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterIdentify(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Identify;

    const char * clusterName = "Identify";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),    //
        make_unique<IdentifyIdentify>(credsIssuerConfig),      //
        make_unique<IdentifyIdentifyQuery>(credsIssuerConfig), //
        make_unique<IdentifyTriggerEffect>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                //
        make_unique<ReadAttribute>(Id, "identify-time", Attributes::IdentifyTime::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "identify-type", Attributes::IdentifyType::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<WriteIdentifyIdentifyTime>(credsIssuerConfig),                                              //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeAttribute>(Id, "identify-time", Attributes::IdentifyTime::Id, credsIssuerConfig),  //
        make_unique<SubscribeAttribute>(Id, "identify-type", Attributes::IdentifyType::Id, credsIssuerConfig),  //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterIlluminanceMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::IlluminanceMeasurement;

    const char * clusterName = "IlluminanceMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "light-sensor-type", Attributes::LightSensorType::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                  //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),         //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                             //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "light-sensor-type", Attributes::LightSensorType::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterKeypadInput(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::KeypadInput;

    const char * clusterName = "KeypadInput";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),        //
        make_unique<KeypadInputSendKeyRequest>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterLevelControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::LevelControl;

    const char * clusterName = "LevelControl";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),               //
        make_unique<LevelControlMove>(credsIssuerConfig),                 //
        make_unique<LevelControlMoveToLevel>(credsIssuerConfig),          //
        make_unique<LevelControlMoveToLevelWithOnOff>(credsIssuerConfig), //
        make_unique<LevelControlMoveWithOnOff>(credsIssuerConfig),        //
        make_unique<LevelControlStep>(credsIssuerConfig),                 //
        make_unique<LevelControlStepWithOnOff>(credsIssuerConfig),        //
        make_unique<LevelControlStop>(credsIssuerConfig),                 //
        make_unique<LevelControlStopWithOnOff>(credsIssuerConfig),        //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                //
        make_unique<ReadAttribute>(Id, "current-level", Attributes::CurrentLevel::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "remaining-time", Attributes::RemainingTime::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "min-level", Attributes::MinLevel::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "max-level", Attributes::MaxLevel::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "current-frequency", Attributes::CurrentFrequency::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "min-frequency", Attributes::MinFrequency::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "max-frequency", Attributes::MaxFrequency::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "options", Attributes::Options::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "on-off-transition-time", Attributes::OnOffTransitionTime::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "on-level", Attributes::OnLevel::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "on-transition-time", Attributes::OnTransitionTime::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "off-transition-time", Attributes::OffTransitionTime::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "default-move-rate", Attributes::DefaultMoveRate::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "start-up-current-level", Attributes::StartUpCurrentLevel::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                         //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                                    //
        make_unique<WriteLevelControlOptions>(credsIssuerConfig),                                                              //
        make_unique<WriteLevelControlOnOffTransitionTime>(credsIssuerConfig),                                                  //
        make_unique<WriteLevelControlOnLevel>(credsIssuerConfig),                                                              //
        make_unique<WriteLevelControlOnTransitionTime>(credsIssuerConfig),                                                     //
        make_unique<WriteLevelControlOffTransitionTime>(credsIssuerConfig),                                                    //
        make_unique<WriteLevelControlDefaultMoveRate>(credsIssuerConfig),                                                      //
        make_unique<WriteLevelControlStartUpCurrentLevel>(credsIssuerConfig),                                                  //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                //
        make_unique<SubscribeAttribute>(Id, "current-level", Attributes::CurrentLevel::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "remaining-time", Attributes::RemainingTime::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "min-level", Attributes::MinLevel::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "max-level", Attributes::MaxLevel::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "current-frequency", Attributes::CurrentFrequency::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "min-frequency", Attributes::MinFrequency::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "max-frequency", Attributes::MaxFrequency::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "options", Attributes::Options::Id, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, "on-off-transition-time", Attributes::OnOffTransitionTime::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "on-level", Attributes::OnLevel::Id, credsIssuerConfig),                           //
        make_unique<SubscribeAttribute>(Id, "on-transition-time", Attributes::OnTransitionTime::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "off-transition-time", Attributes::OffTransitionTime::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "default-move-rate", Attributes::DefaultMoveRate::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "start-up-current-level", Attributes::StartUpCurrentLevel::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterLocalizationConfiguration(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::LocalizationConfiguration;

    const char * clusterName = "LocalizationConfiguration";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                        //
        make_unique<ReadAttribute>(Id, "active-locale", Attributes::ActiveLocale::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "supported-locales", Attributes::SupportedLocales::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),        //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                            //
        make_unique<WriteLocalizationConfigurationActiveLocale>(credsIssuerConfig),                                    //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                        //
        make_unique<SubscribeAttribute>(Id, "active-locale", Attributes::ActiveLocale::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "supported-locales", Attributes::SupportedLocales::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterLowPower(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::LowPower;

    const char * clusterName = "LowPower";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        make_unique<LowPowerSleep>(credsIssuerConfig),      //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterMediaInput(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::MediaInput;

    const char * clusterName = "MediaInput";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),               //
        make_unique<MediaInputHideInputStatusRequest>(credsIssuerConfig), //
        make_unique<MediaInputRenameInputRequest>(credsIssuerConfig),     //
        make_unique<MediaInputSelectInputRequest>(credsIssuerConfig),     //
        make_unique<MediaInputShowInputStatusRequest>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                           //
        make_unique<ReadAttribute>(Id, "media-input-list", Attributes::MediaInputList::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "current-media-input", Attributes::CurrentMediaInput::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                    //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),           //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                           //
        make_unique<SubscribeAttribute>(Id, "media-input-list", Attributes::MediaInputList::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "current-media-input", Attributes::CurrentMediaInput::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterMediaPlayback(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::MediaPlayback;

    const char * clusterName = "MediaPlayback";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),               //
        make_unique<MediaPlaybackFastForwardRequest>(credsIssuerConfig),  //
        make_unique<MediaPlaybackNextRequest>(credsIssuerConfig),         //
        make_unique<MediaPlaybackPauseRequest>(credsIssuerConfig),        //
        make_unique<MediaPlaybackPlayRequest>(credsIssuerConfig),         //
        make_unique<MediaPlaybackPreviousRequest>(credsIssuerConfig),     //
        make_unique<MediaPlaybackRewindRequest>(credsIssuerConfig),       //
        make_unique<MediaPlaybackSeekRequest>(credsIssuerConfig),         //
        make_unique<MediaPlaybackSkipBackwardRequest>(credsIssuerConfig), //
        make_unique<MediaPlaybackSkipForwardRequest>(credsIssuerConfig),  //
        make_unique<MediaPlaybackStartOverRequest>(credsIssuerConfig),    //
        make_unique<MediaPlaybackStopRequest>(credsIssuerConfig),         //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<ReadAttribute>(Id, "playback-state", Attributes::PlaybackState::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "start-time", Attributes::StartTime::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "duration", Attributes::Duration::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "position", Attributes::Position::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "playback-speed", Attributes::PlaybackSpeed::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "seek-range-end", Attributes::SeekRangeEnd::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "seek-range-start", Attributes::SeekRangeStart::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                              //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),     //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<SubscribeAttribute>(Id, "playback-state", Attributes::PlaybackState::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "start-time", Attributes::StartTime::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "duration", Attributes::Duration::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "position", Attributes::Position::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "playback-speed", Attributes::PlaybackSpeed::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "seek-range-end", Attributes::SeekRangeEnd::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "seek-range-start", Attributes::SeekRangeStart::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterModeSelect(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ModeSelect;

    const char * clusterName = "ModeSelect";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),     //
        make_unique<ModeSelectChangeToMode>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                    //
        make_unique<ReadAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "on-mode", Attributes::OnMode::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "start-up-mode", Attributes::StartUpMode::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "description", Attributes::Description::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                             //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),    //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                        //
        make_unique<WriteModeSelectOnMode>(credsIssuerConfig),                                                     //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                    //
        make_unique<SubscribeAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "on-mode", Attributes::OnMode::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "start-up-mode", Attributes::StartUpMode::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "description", Attributes::Description::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterNetworkCommissioning(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::NetworkCommissioning;

    const char * clusterName = "NetworkCommissioning";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                           //
        make_unique<NetworkCommissioningAddOrUpdateThreadNetwork>(credsIssuerConfig), //
        make_unique<NetworkCommissioningAddOrUpdateWiFiNetwork>(credsIssuerConfig),   //
        make_unique<NetworkCommissioningConnectNetwork>(credsIssuerConfig),           //
        make_unique<NetworkCommissioningRemoveNetwork>(credsIssuerConfig),            //
        make_unique<NetworkCommissioningReorderNetwork>(credsIssuerConfig),           //
        make_unique<NetworkCommissioningScanNetworks>(credsIssuerConfig),             //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                    //
        make_unique<ReadAttribute>(Id, "max-networks", Attributes::MaxNetworks::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "networks", Attributes::Networks::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "scan-max-time-seconds", Attributes::ScanMaxTimeSeconds::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "connect-max-time-seconds", Attributes::ConnectMaxTimeSeconds::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "interface-enabled", Attributes::InterfaceEnabled::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "last-networking-status", Attributes::LastNetworkingStatus::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "last-network-id", Attributes::LastNetworkID::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "last-connect-error-value", Attributes::LastConnectErrorValue::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                       //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),              //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                                  //
        make_unique<WriteNetworkCommissioningInterfaceEnabled>(credsIssuerConfig),                                           //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                              //
        make_unique<SubscribeAttribute>(Id, "max-networks", Attributes::MaxNetworks::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "networks", Attributes::Networks::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "scan-max-time-seconds", Attributes::ScanMaxTimeSeconds::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "connect-max-time-seconds", Attributes::ConnectMaxTimeSeconds::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "interface-enabled", Attributes::InterfaceEnabled::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "last-networking-status", Attributes::LastNetworkingStatus::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "last-network-id", Attributes::LastNetworkID::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "last-connect-error-value", Attributes::LastConnectErrorValue::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterOtaSoftwareUpdateProvider(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::OtaSoftwareUpdateProvider;

    const char * clusterName = "OtaSoftwareUpdateProvider";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                           //
        make_unique<OtaSoftwareUpdateProviderApplyUpdateRequest>(credsIssuerConfig),  //
        make_unique<OtaSoftwareUpdateProviderNotifyUpdateApplied>(credsIssuerConfig), //
        make_unique<OtaSoftwareUpdateProviderQueryImage>(credsIssuerConfig),          //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                           //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),      //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                      //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterOtaSoftwareUpdateRequestor(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::OtaSoftwareUpdateRequestor;

    const char * clusterName = "OtaSoftwareUpdateRequestor";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                            //
        make_unique<OtaSoftwareUpdateRequestorAnnounceOtaProvider>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                    //
        make_unique<ReadAttribute>(Id, "default-ota-providers", Attributes::DefaultOtaProviders::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "update-possible", Attributes::UpdatePossible::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "update-state", Attributes::UpdateState::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "update-state-progress", Attributes::UpdateStateProgress::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),               //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                                   //
        make_unique<WriteOtaSoftwareUpdateRequestorDefaultOtaProviders>(credsIssuerConfig),                                   //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<SubscribeAttribute>(Id, "default-ota-providers", Attributes::DefaultOtaProviders::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "update-possible", Attributes::UpdatePossible::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "update-state", Attributes::UpdateState::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "update-state-progress", Attributes::UpdateStateProgress::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),          //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                       //
        make_unique<ReadEvent>(Id, "state-transition", Events::StateTransition::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "version-applied", Events::VersionApplied::Id, credsIssuerConfig),        //
        make_unique<ReadEvent>(Id, "download-error", Events::DownloadError::Id, credsIssuerConfig),          //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                  //
        make_unique<SubscribeEvent>(Id, "state-transition", Events::StateTransition::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "version-applied", Events::VersionApplied::Id, credsIssuerConfig),   //
        make_unique<SubscribeEvent>(Id, "download-error", Events::DownloadError::Id, credsIssuerConfig),     //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterOccupancySensing(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::OccupancySensing;

    const char * clusterName = "OccupancySensing";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<ReadAttribute>(Id, "occupancy", Attributes::Occupancy::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "occupancy-sensor-type", Attributes::OccupancySensorType::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "occupancy-sensor-type-bitmap", Attributes::OccupancySensorTypeBitmap::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),               //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                                   //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<SubscribeAttribute>(Id, "occupancy", Attributes::Occupancy::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "occupancy-sensor-type", Attributes::OccupancySensorType::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "occupancy-sensor-type-bitmap", Attributes::OccupancySensorTypeBitmap::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterOnOff(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::OnOff;

    const char * clusterName = "OnOff";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),           //
        make_unique<OnOffOff>(credsIssuerConfig),                     //
        make_unique<OnOffOffWithEffect>(credsIssuerConfig),           //
        make_unique<OnOffOn>(credsIssuerConfig),                      //
        make_unique<OnOffOnWithRecallGlobalScene>(credsIssuerConfig), //
        make_unique<OnOffOnWithTimedOff>(credsIssuerConfig),          //
        make_unique<OnOffToggle>(credsIssuerConfig),                  //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                             //
        make_unique<ReadAttribute>(Id, "on-off", Attributes::OnOff::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "global-scene-control", Attributes::GlobalSceneControl::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "on-time", Attributes::OnTime::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "off-wait-time", Attributes::OffWaitTime::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "start-up-on-off", Attributes::StartUpOnOff::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                      //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),             //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<WriteOnOffOnTime>(credsIssuerConfig),                                                                   //
        make_unique<WriteOnOffOffWaitTime>(credsIssuerConfig),                                                              //
        make_unique<WriteOnOffStartUpOnOff>(credsIssuerConfig),                                                             //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                             //
        make_unique<SubscribeAttribute>(Id, "on-off", Attributes::OnOff::Id, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, "global-scene-control", Attributes::GlobalSceneControl::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "on-time", Attributes::OnTime::Id, credsIssuerConfig),                          //
        make_unique<SubscribeAttribute>(Id, "off-wait-time", Attributes::OffWaitTime::Id, credsIssuerConfig),               //
        make_unique<SubscribeAttribute>(Id, "start-up-on-off", Attributes::StartUpOnOff::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterOnOffSwitchConfiguration(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::OnOffSwitchConfiguration;

    const char * clusterName = "OnOffSwitchConfiguration";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                  //
        make_unique<ReadAttribute>(Id, "switch-type", Attributes::SwitchType::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "switch-actions", Attributes::SwitchActions::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                           //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),  //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                      //
        make_unique<WriteOnOffSwitchConfigurationSwitchActions>(credsIssuerConfig),                              //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                  //
        make_unique<SubscribeAttribute>(Id, "switch-type", Attributes::SwitchType::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "switch-actions", Attributes::SwitchActions::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterOperationalCredentials(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::OperationalCredentials;

    const char * clusterName = "OperationalCredentials";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                                 //
        make_unique<OperationalCredentialsAddNOC>(credsIssuerConfig),                       //
        make_unique<OperationalCredentialsAddTrustedRootCertificate>(credsIssuerConfig),    //
        make_unique<OperationalCredentialsAttestationRequest>(credsIssuerConfig),           //
        make_unique<OperationalCredentialsCSRRequest>(credsIssuerConfig),                   //
        make_unique<OperationalCredentialsCertificateChainRequest>(credsIssuerConfig),      //
        make_unique<OperationalCredentialsRemoveFabric>(credsIssuerConfig),                 //
        make_unique<OperationalCredentialsRemoveTrustedRootCertificate>(credsIssuerConfig), //
        make_unique<OperationalCredentialsUpdateFabricLabel>(credsIssuerConfig),            //
        make_unique<OperationalCredentialsUpdateNOC>(credsIssuerConfig),                    //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                       //
        make_unique<ReadAttribute>(Id, "nocs", Attributes::NOCs::Id, credsIssuerConfig),                                         //
        make_unique<ReadAttribute>(Id, "fabrics-list", Attributes::FabricsList::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "supported-fabrics", Attributes::SupportedFabrics::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "commissioned-fabrics", Attributes::CommissionedFabrics::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "trusted-root-certificates", Attributes::TrustedRootCertificates::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "current-fabric-index", Attributes::CurrentFabricIndex::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                       //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),              //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                                  //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                              //
        make_unique<SubscribeAttribute>(Id, "nocs", Attributes::NOCs::Id, credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, "fabrics-list", Attributes::FabricsList::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "supported-fabrics", Attributes::SupportedFabrics::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "commissioned-fabrics", Attributes::CommissionedFabrics::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "trusted-root-certificates", Attributes::TrustedRootCertificates::Id,
                                        credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "current-fabric-index", Attributes::CurrentFabricIndex::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterPowerSource(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::PowerSource;

    const char * clusterName = "PowerSource";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                       //
        make_unique<ReadAttribute>(Id, "status", Attributes::Status::Id, credsIssuerConfig),                                     //
        make_unique<ReadAttribute>(Id, "order", Attributes::Order::Id, credsIssuerConfig),                                       //
        make_unique<ReadAttribute>(Id, "description", Attributes::Description::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "battery-voltage", Attributes::BatteryVoltage::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "battery-percent-remaining", Attributes::BatteryPercentRemaining::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "battery-time-remaining", Attributes::BatteryTimeRemaining::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "battery-charge-level", Attributes::BatteryChargeLevel::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "active-battery-faults", Attributes::ActiveBatteryFaults::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "battery-charge-state", Attributes::BatteryChargeState::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                             //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),    //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                        //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                    //
        make_unique<SubscribeAttribute>(Id, "status", Attributes::Status::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "order", Attributes::Order::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "description", Attributes::Description::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "battery-voltage", Attributes::BatteryVoltage::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "battery-percent-remaining", Attributes::BatteryPercentRemaining::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "battery-time-remaining", Attributes::BatteryTimeRemaining::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "battery-charge-level", Attributes::BatteryChargeLevel::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "active-battery-faults", Attributes::ActiveBatteryFaults::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "battery-charge-state", Attributes::BatteryChargeState::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterPowerSourceConfiguration(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::PowerSourceConfiguration;

    const char * clusterName = "PowerSourceConfiguration";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                     //
        make_unique<ReadAttribute>(Id, "sources", Attributes::Sources::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeAttribute>(Id, "sources", Attributes::Sources::Id, credsIssuerConfig),             //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterPressureMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::PressureMeasurement;

    const char * clusterName = "PressureMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                              //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),         //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                             //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),    //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterPumpConfigurationAndControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::PumpConfigurationAndControl;

    const char * clusterName = "PumpConfigurationAndControl";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "max-pressure", Attributes::MaxPressure::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "max-speed", Attributes::MaxSpeed::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "max-flow", Attributes::MaxFlow::Id, credsIssuerConfig),                                //
        make_unique<ReadAttribute>(Id, "min-const-pressure", Attributes::MinConstPressure::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "max-const-pressure", Attributes::MaxConstPressure::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "min-comp-pressure", Attributes::MinCompPressure::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "max-comp-pressure", Attributes::MaxCompPressure::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "min-const-speed", Attributes::MinConstSpeed::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "max-const-speed", Attributes::MaxConstSpeed::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "min-const-flow", Attributes::MinConstFlow::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "max-const-flow", Attributes::MaxConstFlow::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "min-const-temp", Attributes::MinConstTemp::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "max-const-temp", Attributes::MaxConstTemp::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "pump-status", Attributes::PumpStatus::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "effective-operation-mode", Attributes::EffectiveOperationMode::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "effective-control-mode", Attributes::EffectiveControlMode::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "capacity", Attributes::Capacity::Id, credsIssuerConfig),                               //
        make_unique<ReadAttribute>(Id, "speed", Attributes::Speed::Id, credsIssuerConfig),                                     //
        make_unique<ReadAttribute>(Id, "lifetime-running-hours", Attributes::LifetimeRunningHours::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "power", Attributes::Power::Id, credsIssuerConfig),                                     //
        make_unique<ReadAttribute>(Id, "lifetime-energy-consumed", Attributes::LifetimeEnergyConsumed::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "operation-mode", Attributes::OperationMode::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "control-mode", Attributes::ControlMode::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "alarm-mask", Attributes::AlarmMask::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                  //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),         //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                             //
        make_unique<WritePumpConfigurationAndControlLifetimeRunningHours>(credsIssuerConfig),                           //
        make_unique<WritePumpConfigurationAndControlLifetimeEnergyConsumed>(credsIssuerConfig),                         //
        make_unique<WritePumpConfigurationAndControlOperationMode>(credsIssuerConfig),                                  //
        make_unique<WritePumpConfigurationAndControlControlMode>(credsIssuerConfig),                                    //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeAttribute>(Id, "max-pressure", Attributes::MaxPressure::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "max-speed", Attributes::MaxSpeed::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "max-flow", Attributes::MaxFlow::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "min-const-pressure", Attributes::MinConstPressure::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "max-const-pressure", Attributes::MaxConstPressure::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "min-comp-pressure", Attributes::MinCompPressure::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "max-comp-pressure", Attributes::MaxCompPressure::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "min-const-speed", Attributes::MinConstSpeed::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "max-const-speed", Attributes::MaxConstSpeed::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "min-const-flow", Attributes::MinConstFlow::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "max-const-flow", Attributes::MaxConstFlow::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "min-const-temp", Attributes::MinConstTemp::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "max-const-temp", Attributes::MaxConstTemp::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "pump-status", Attributes::PumpStatus::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "effective-operation-mode", Attributes::EffectiveOperationMode::Id,
                                        credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, "effective-control-mode", Attributes::EffectiveControlMode::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "capacity", Attributes::Capacity::Id, credsIssuerConfig),                           //
        make_unique<SubscribeAttribute>(Id, "speed", Attributes::Speed::Id, credsIssuerConfig),                                 //
        make_unique<SubscribeAttribute>(Id, "lifetime-running-hours", Attributes::LifetimeRunningHours::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "power", Attributes::Power::Id, credsIssuerConfig),                                 //
        make_unique<SubscribeAttribute>(Id, "lifetime-energy-consumed", Attributes::LifetimeEnergyConsumed::Id,
                                        credsIssuerConfig),                                                      //
        make_unique<SubscribeAttribute>(Id, "operation-mode", Attributes::OperationMode::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "control-mode", Attributes::ControlMode::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "alarm-mask", Attributes::AlarmMask::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                                            //
        make_unique<ReadEvent>(Id, "supply-voltage-low", Events::SupplyVoltageLow::Id, credsIssuerConfig),                        //
        make_unique<ReadEvent>(Id, "supply-voltage-high", Events::SupplyVoltageHigh::Id, credsIssuerConfig),                      //
        make_unique<ReadEvent>(Id, "power-missing-phase", Events::PowerMissingPhase::Id, credsIssuerConfig),                      //
        make_unique<ReadEvent>(Id, "system-pressure-low", Events::SystemPressureLow::Id, credsIssuerConfig),                      //
        make_unique<ReadEvent>(Id, "system-pressure-high", Events::SystemPressureHigh::Id, credsIssuerConfig),                    //
        make_unique<ReadEvent>(Id, "dry-running", Events::DryRunning::Id, credsIssuerConfig),                                     //
        make_unique<ReadEvent>(Id, "motor-temperature-high", Events::MotorTemperatureHigh::Id, credsIssuerConfig),                //
        make_unique<ReadEvent>(Id, "pump-motor-fatal-failure", Events::PumpMotorFatalFailure::Id, credsIssuerConfig),             //
        make_unique<ReadEvent>(Id, "electronic-temperature-high", Events::ElectronicTemperatureHigh::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "pump-blocked", Events::PumpBlocked::Id, credsIssuerConfig),                                   //
        make_unique<ReadEvent>(Id, "sensor-failure", Events::SensorFailure::Id, credsIssuerConfig),                               //
        make_unique<ReadEvent>(Id, "electronic-non-fatal-failure", Events::ElectronicNonFatalFailure::Id, credsIssuerConfig),     //
        make_unique<ReadEvent>(Id, "electronic-fatal-failure", Events::ElectronicFatalFailure::Id, credsIssuerConfig),            //
        make_unique<ReadEvent>(Id, "general-fault", Events::GeneralFault::Id, credsIssuerConfig),                                 //
        make_unique<ReadEvent>(Id, "leakage", Events::Leakage::Id, credsIssuerConfig),                                            //
        make_unique<ReadEvent>(Id, "air-detection", Events::AirDetection::Id, credsIssuerConfig),                                 //
        make_unique<ReadEvent>(Id, "turbine-operation", Events::TurbineOperation::Id, credsIssuerConfig),                         //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                                       //
        make_unique<SubscribeEvent>(Id, "supply-voltage-low", Events::SupplyVoltageLow::Id, credsIssuerConfig),                   //
        make_unique<SubscribeEvent>(Id, "supply-voltage-high", Events::SupplyVoltageHigh::Id, credsIssuerConfig),                 //
        make_unique<SubscribeEvent>(Id, "power-missing-phase", Events::PowerMissingPhase::Id, credsIssuerConfig),                 //
        make_unique<SubscribeEvent>(Id, "system-pressure-low", Events::SystemPressureLow::Id, credsIssuerConfig),                 //
        make_unique<SubscribeEvent>(Id, "system-pressure-high", Events::SystemPressureHigh::Id, credsIssuerConfig),               //
        make_unique<SubscribeEvent>(Id, "dry-running", Events::DryRunning::Id, credsIssuerConfig),                                //
        make_unique<SubscribeEvent>(Id, "motor-temperature-high", Events::MotorTemperatureHigh::Id, credsIssuerConfig),           //
        make_unique<SubscribeEvent>(Id, "pump-motor-fatal-failure", Events::PumpMotorFatalFailure::Id, credsIssuerConfig),        //
        make_unique<SubscribeEvent>(Id, "electronic-temperature-high", Events::ElectronicTemperatureHigh::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "pump-blocked", Events::PumpBlocked::Id, credsIssuerConfig),                              //
        make_unique<SubscribeEvent>(Id, "sensor-failure", Events::SensorFailure::Id, credsIssuerConfig),                          //
        make_unique<SubscribeEvent>(Id, "electronic-non-fatal-failure", Events::ElectronicNonFatalFailure::Id,
                                    credsIssuerConfig),                                                                     //
        make_unique<SubscribeEvent>(Id, "electronic-fatal-failure", Events::ElectronicFatalFailure::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "general-fault", Events::GeneralFault::Id, credsIssuerConfig),                      //
        make_unique<SubscribeEvent>(Id, "leakage", Events::Leakage::Id, credsIssuerConfig),                                 //
        make_unique<SubscribeEvent>(Id, "air-detection", Events::AirDetection::Id, credsIssuerConfig),                      //
        make_unique<SubscribeEvent>(Id, "turbine-operation", Events::TurbineOperation::Id, credsIssuerConfig),              //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterRelativeHumidityMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::RelativeHumidityMeasurement;

    const char * clusterName = "RelativeHumidityMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                  //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),         //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                             //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterScenes(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Scenes;

    const char * clusterName = "Scenes";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),       //
        make_unique<ScenesAddScene>(credsIssuerConfig),           //
        make_unique<ScenesGetSceneMembership>(credsIssuerConfig), //
        make_unique<ScenesRecallScene>(credsIssuerConfig),        //
        make_unique<ScenesRemoveAllScenes>(credsIssuerConfig),    //
        make_unique<ScenesRemoveScene>(credsIssuerConfig),        //
        make_unique<ScenesStoreScene>(credsIssuerConfig),         //
        make_unique<ScenesViewScene>(credsIssuerConfig),          //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                //
        make_unique<ReadAttribute>(Id, "scene-count", Attributes::SceneCount::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "current-scene", Attributes::CurrentScene::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "current-group", Attributes::CurrentGroup::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "scene-valid", Attributes::SceneValid::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "name-support", Attributes::NameSupport::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeAttribute>(Id, "scene-count", Attributes::SceneCount::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "current-scene", Attributes::CurrentScene::Id, credsIssuerConfig),  //
        make_unique<SubscribeAttribute>(Id, "current-group", Attributes::CurrentGroup::Id, credsIssuerConfig),  //
        make_unique<SubscribeAttribute>(Id, "scene-valid", Attributes::SceneValid::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "name-support", Attributes::NameSupport::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterSoftwareDiagnostics(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::SoftwareDiagnostics;

    const char * clusterName = "SoftwareDiagnostics";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                 //
        make_unique<SoftwareDiagnosticsResetWatermarks>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                       //
        make_unique<ReadAttribute>(Id, "thread-metrics", Attributes::ThreadMetrics::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "current-heap-free", Attributes::CurrentHeapFree::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "current-heap-used", Attributes::CurrentHeapUsed::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "current-heap-high-watermark", Attributes::CurrentHeapHighWatermark::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),       //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                           //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                       //
        make_unique<SubscribeAttribute>(Id, "thread-metrics", Attributes::ThreadMetrics::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "current-heap-free", Attributes::CurrentHeapFree::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "current-heap-used", Attributes::CurrentHeapUsed::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "current-heap-high-watermark", Attributes::CurrentHeapHighWatermark::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                   //
        make_unique<ReadEvent>(Id, "software-fault", Events::SoftwareFault::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                              //
        make_unique<SubscribeEvent>(Id, "software-fault", Events::SoftwareFault::Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterSwitch(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Switch;

    const char * clusterName = "Switch";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                           //
        make_unique<ReadAttribute>(Id, "number-of-positions", Attributes::NumberOfPositions::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "current-position", Attributes::CurrentPosition::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "multi-press-max", Attributes::MultiPressMax::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                    //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),           //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                           //
        make_unique<SubscribeAttribute>(Id, "number-of-positions", Attributes::NumberOfPositions::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "current-position", Attributes::CurrentPosition::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "multi-press-max", Attributes::MultiPressMax::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                              //
        make_unique<ReadEvent>(Id, "switch-latched", Events::SwitchLatched::Id, credsIssuerConfig),                 //
        make_unique<ReadEvent>(Id, "initial-press", Events::InitialPress::Id, credsIssuerConfig),                   //
        make_unique<ReadEvent>(Id, "long-press", Events::LongPress::Id, credsIssuerConfig),                         //
        make_unique<ReadEvent>(Id, "short-release", Events::ShortRelease::Id, credsIssuerConfig),                   //
        make_unique<ReadEvent>(Id, "long-release", Events::LongRelease::Id, credsIssuerConfig),                     //
        make_unique<ReadEvent>(Id, "multi-press-ongoing", Events::MultiPressOngoing::Id, credsIssuerConfig),        //
        make_unique<ReadEvent>(Id, "multi-press-complete", Events::MultiPressComplete::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeEvent>(Id, "switch-latched", Events::SwitchLatched::Id, credsIssuerConfig),            //
        make_unique<SubscribeEvent>(Id, "initial-press", Events::InitialPress::Id, credsIssuerConfig),              //
        make_unique<SubscribeEvent>(Id, "long-press", Events::LongPress::Id, credsIssuerConfig),                    //
        make_unique<SubscribeEvent>(Id, "short-release", Events::ShortRelease::Id, credsIssuerConfig),              //
        make_unique<SubscribeEvent>(Id, "long-release", Events::LongRelease::Id, credsIssuerConfig),                //
        make_unique<SubscribeEvent>(Id, "multi-press-ongoing", Events::MultiPressOngoing::Id, credsIssuerConfig),   //
        make_unique<SubscribeEvent>(Id, "multi-press-complete", Events::MultiPressComplete::Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterTargetNavigator(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::TargetNavigator;

    const char * clusterName = "TargetNavigator";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                   //
        make_unique<TargetNavigatorNavigateTargetRequest>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "target-navigator-list", Attributes::TargetNavigatorList::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "current-navigator-target", Attributes::CurrentNavigatorTarget::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),               //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                                   //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<SubscribeAttribute>(Id, "target-navigator-list", Attributes::TargetNavigatorList::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "current-navigator-target", Attributes::CurrentNavigatorTarget::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterTemperatureMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::TemperatureMeasurement;

    const char * clusterName = "TemperatureMeasurement";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                              //
        make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),         //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                             //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                         //
        make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),    //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterTestCluster(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::TestCluster;

    const char * clusterName = "TestCluster";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                                 //
        make_unique<TestClusterSimpleStructEchoRequest>(credsIssuerConfig),                 //
        make_unique<TestClusterTest>(credsIssuerConfig),                                    //
        make_unique<TestClusterTestAddArguments>(credsIssuerConfig),                        //
        make_unique<TestClusterTestEmitTestEventRequest>(credsIssuerConfig),                //
        make_unique<TestClusterTestEnumsRequest>(credsIssuerConfig),                        //
        make_unique<TestClusterTestListInt8UArgumentRequest>(credsIssuerConfig),            //
        make_unique<TestClusterTestListInt8UReverseRequest>(credsIssuerConfig),             //
        make_unique<TestClusterTestListNestedStructListArgumentRequest>(credsIssuerConfig), //
        make_unique<TestClusterTestListStructArgumentRequest>(credsIssuerConfig),           //
        make_unique<TestClusterTestNestedStructArgumentRequest>(credsIssuerConfig),         //
        make_unique<TestClusterTestNestedStructListArgumentRequest>(credsIssuerConfig),     //
        make_unique<TestClusterTestNotHandled>(credsIssuerConfig),                          //
        make_unique<TestClusterTestNullableOptionalRequest>(credsIssuerConfig),             //
        make_unique<TestClusterTestSimpleOptionalArgumentRequest>(credsIssuerConfig),       //
        make_unique<TestClusterTestSpecific>(credsIssuerConfig),                            //
        make_unique<TestClusterTestStructArgumentRequest>(credsIssuerConfig),               //
        make_unique<TestClusterTestUnknownCommand>(credsIssuerConfig),                      //
        make_unique<TestClusterTimedInvokeRequest>(credsIssuerConfig),                      //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                    //
        make_unique<ReadAttribute>(Id, "boolean", Attributes::Boolean::Id, credsIssuerConfig),                                //
        make_unique<ReadAttribute>(Id, "bitmap8", Attributes::Bitmap8::Id, credsIssuerConfig),                                //
        make_unique<ReadAttribute>(Id, "bitmap16", Attributes::Bitmap16::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "bitmap32", Attributes::Bitmap32::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "bitmap64", Attributes::Bitmap64::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "int8u", Attributes::Int8u::Id, credsIssuerConfig),                                    //
        make_unique<ReadAttribute>(Id, "int16u", Attributes::Int16u::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int24u", Attributes::Int24u::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int32u", Attributes::Int32u::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int40u", Attributes::Int40u::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int48u", Attributes::Int48u::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int56u", Attributes::Int56u::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int64u", Attributes::Int64u::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int8s", Attributes::Int8s::Id, credsIssuerConfig),                                    //
        make_unique<ReadAttribute>(Id, "int16s", Attributes::Int16s::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int24s", Attributes::Int24s::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int32s", Attributes::Int32s::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int40s", Attributes::Int40s::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int48s", Attributes::Int48s::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int56s", Attributes::Int56s::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "int64s", Attributes::Int64s::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "enum8", Attributes::Enum8::Id, credsIssuerConfig),                                    //
        make_unique<ReadAttribute>(Id, "enum16", Attributes::Enum16::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "float-single", Attributes::FloatSingle::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "float-double", Attributes::FloatDouble::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "octet-string", Attributes::OctetString::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "list-int8u", Attributes::ListInt8u::Id, credsIssuerConfig),                           //
        make_unique<ReadAttribute>(Id, "list-octet-string", Attributes::ListOctetString::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "list-struct-octet-string", Attributes::ListStructOctetString::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "long-octet-string", Attributes::LongOctetString::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "char-string", Attributes::CharString::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "long-char-string", Attributes::LongCharString::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "epoch-us", Attributes::EpochUs::Id, credsIssuerConfig),                               //
        make_unique<ReadAttribute>(Id, "epoch-s", Attributes::EpochS::Id, credsIssuerConfig),                                 //
        make_unique<ReadAttribute>(Id, "vendor-id", Attributes::VendorId::Id, credsIssuerConfig),                             //
        make_unique<ReadAttribute>(Id, "list-nullables-and-optionals-struct", Attributes::ListNullablesAndOptionalsStruct::Id,
                                   credsIssuerConfig),                                                                       //
        make_unique<ReadAttribute>(Id, "enum-attr", Attributes::EnumAttr::Id, credsIssuerConfig),                            //
        make_unique<ReadAttribute>(Id, "struct-attr", Attributes::StructAttr::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "range-restricted-int8u", Attributes::RangeRestrictedInt8u::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "range-restricted-int8s", Attributes::RangeRestrictedInt8s::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "range-restricted-int16u", Attributes::RangeRestrictedInt16u::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "range-restricted-int16s", Attributes::RangeRestrictedInt16s::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "list-long-octet-string", Attributes::ListLongOctetString::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "timed-write-boolean", Attributes::TimedWriteBoolean::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "general-error-boolean", Attributes::GeneralErrorBoolean::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "cluster-error-boolean", Attributes::ClusterErrorBoolean::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "unsupported", Attributes::Unsupported::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "nullable-boolean", Attributes::NullableBoolean::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "nullable-bitmap8", Attributes::NullableBitmap8::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "nullable-bitmap16", Attributes::NullableBitmap16::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "nullable-bitmap32", Attributes::NullableBitmap32::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "nullable-bitmap64", Attributes::NullableBitmap64::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "nullable-int8u", Attributes::NullableInt8u::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "nullable-int16u", Attributes::NullableInt16u::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int24u", Attributes::NullableInt24u::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int32u", Attributes::NullableInt32u::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int40u", Attributes::NullableInt40u::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int48u", Attributes::NullableInt48u::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int56u", Attributes::NullableInt56u::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int64u", Attributes::NullableInt64u::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int8s", Attributes::NullableInt8s::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "nullable-int16s", Attributes::NullableInt16s::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int24s", Attributes::NullableInt24s::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int32s", Attributes::NullableInt32s::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int40s", Attributes::NullableInt40s::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int48s", Attributes::NullableInt48s::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int56s", Attributes::NullableInt56s::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-int64s", Attributes::NullableInt64s::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-enum8", Attributes::NullableEnum8::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "nullable-enum16", Attributes::NullableEnum16::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-float-single", Attributes::NullableFloatSingle::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "nullable-float-double", Attributes::NullableFloatDouble::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "nullable-octet-string", Attributes::NullableOctetString::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "nullable-char-string", Attributes::NullableCharString::Id, credsIssuerConfig),       //
        make_unique<ReadAttribute>(Id, "nullable-enum-attr", Attributes::NullableEnumAttr::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "nullable-struct", Attributes::NullableStruct::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "nullable-range-restricted-int8u", Attributes::NullableRangeRestrictedInt8u::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "nullable-range-restricted-int8s", Attributes::NullableRangeRestrictedInt8s::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "nullable-range-restricted-int16u", Attributes::NullableRangeRestrictedInt16u::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "nullable-range-restricted-int16s", Attributes::NullableRangeRestrictedInt16s::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),       //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                           //
        make_unique<WriteTestClusterBoolean>(credsIssuerConfig),                                                      //
        make_unique<WriteTestClusterBitmap8>(credsIssuerConfig),                                                      //
        make_unique<WriteTestClusterBitmap16>(credsIssuerConfig),                                                     //
        make_unique<WriteTestClusterBitmap32>(credsIssuerConfig),                                                     //
        make_unique<WriteTestClusterBitmap64>(credsIssuerConfig),                                                     //
        make_unique<WriteTestClusterInt8u>(credsIssuerConfig),                                                        //
        make_unique<WriteTestClusterInt16u>(credsIssuerConfig),                                                       //
        make_unique<WriteTestClusterInt24u>(credsIssuerConfig),                                                       //
        make_unique<WriteTestClusterInt32u>(credsIssuerConfig),                                                       //
        make_unique<WriteTestClusterInt40u>(credsIssuerConfig),                                                       //
        make_unique<WriteTestClusterInt48u>(credsIssuerConfig),                                                       //
        make_unique<WriteTestClusterInt56u>(credsIssuerConfig),                                                       //
        make_unique<WriteTestClusterInt64u>(credsIssuerConfig),                                                       //
        make_unique<WriteTestClusterInt8s>(credsIssuerConfig),                                                        //
        make_unique<WriteTestClusterInt16s>(credsIssuerConfig),                                                       //
        make_unique<WriteTestClusterInt24s>(credsIssuerConfig),                                                       //
        make_unique<WriteTestClusterInt32s>(credsIssuerConfig),                                                       //
        make_unique<WriteTestClusterInt40s>(credsIssuerConfig),                                                       //
        make_unique<WriteTestClusterInt48s>(credsIssuerConfig),                                                       //
        make_unique<WriteTestClusterInt56s>(credsIssuerConfig),                                                       //
        make_unique<WriteTestClusterInt64s>(credsIssuerConfig),                                                       //
        make_unique<WriteTestClusterEnum8>(credsIssuerConfig),                                                        //
        make_unique<WriteTestClusterEnum16>(credsIssuerConfig),                                                       //
        make_unique<WriteTestClusterFloatSingle>(credsIssuerConfig),                                                  //
        make_unique<WriteTestClusterFloatDouble>(credsIssuerConfig),                                                  //
        make_unique<WriteTestClusterOctetString>(credsIssuerConfig),                                                  //
        make_unique<WriteTestClusterListInt8u>(credsIssuerConfig),                                                    //
        make_unique<WriteTestClusterListOctetString>(credsIssuerConfig),                                              //
        make_unique<WriteTestClusterListStructOctetString>(credsIssuerConfig),                                        //
        make_unique<WriteTestClusterLongOctetString>(credsIssuerConfig),                                              //
        make_unique<WriteTestClusterCharString>(credsIssuerConfig),                                                   //
        make_unique<WriteTestClusterLongCharString>(credsIssuerConfig),                                               //
        make_unique<WriteTestClusterEpochUs>(credsIssuerConfig),                                                      //
        make_unique<WriteTestClusterEpochS>(credsIssuerConfig),                                                       //
        make_unique<WriteTestClusterVendorId>(credsIssuerConfig),                                                     //
        make_unique<WriteTestClusterListNullablesAndOptionalsStruct>(credsIssuerConfig),                              //
        make_unique<WriteTestClusterEnumAttr>(credsIssuerConfig),                                                     //
        make_unique<WriteTestClusterStructAttr>(credsIssuerConfig),                                                   //
        make_unique<WriteTestClusterRangeRestrictedInt8u>(credsIssuerConfig),                                         //
        make_unique<WriteTestClusterRangeRestrictedInt8s>(credsIssuerConfig),                                         //
        make_unique<WriteTestClusterRangeRestrictedInt16u>(credsIssuerConfig),                                        //
        make_unique<WriteTestClusterRangeRestrictedInt16s>(credsIssuerConfig),                                        //
        make_unique<WriteTestClusterTimedWriteBoolean>(credsIssuerConfig),                                            //
        make_unique<WriteTestClusterGeneralErrorBoolean>(credsIssuerConfig),                                          //
        make_unique<WriteTestClusterClusterErrorBoolean>(credsIssuerConfig),                                          //
        make_unique<WriteTestClusterUnsupported>(credsIssuerConfig),                                                  //
        make_unique<WriteTestClusterNullableBoolean>(credsIssuerConfig),                                              //
        make_unique<WriteTestClusterNullableBitmap8>(credsIssuerConfig),                                              //
        make_unique<WriteTestClusterNullableBitmap16>(credsIssuerConfig),                                             //
        make_unique<WriteTestClusterNullableBitmap32>(credsIssuerConfig),                                             //
        make_unique<WriteTestClusterNullableBitmap64>(credsIssuerConfig),                                             //
        make_unique<WriteTestClusterNullableInt8u>(credsIssuerConfig),                                                //
        make_unique<WriteTestClusterNullableInt16u>(credsIssuerConfig),                                               //
        make_unique<WriteTestClusterNullableInt24u>(credsIssuerConfig),                                               //
        make_unique<WriteTestClusterNullableInt32u>(credsIssuerConfig),                                               //
        make_unique<WriteTestClusterNullableInt40u>(credsIssuerConfig),                                               //
        make_unique<WriteTestClusterNullableInt48u>(credsIssuerConfig),                                               //
        make_unique<WriteTestClusterNullableInt56u>(credsIssuerConfig),                                               //
        make_unique<WriteTestClusterNullableInt64u>(credsIssuerConfig),                                               //
        make_unique<WriteTestClusterNullableInt8s>(credsIssuerConfig),                                                //
        make_unique<WriteTestClusterNullableInt16s>(credsIssuerConfig),                                               //
        make_unique<WriteTestClusterNullableInt24s>(credsIssuerConfig),                                               //
        make_unique<WriteTestClusterNullableInt32s>(credsIssuerConfig),                                               //
        make_unique<WriteTestClusterNullableInt40s>(credsIssuerConfig),                                               //
        make_unique<WriteTestClusterNullableInt48s>(credsIssuerConfig),                                               //
        make_unique<WriteTestClusterNullableInt56s>(credsIssuerConfig),                                               //
        make_unique<WriteTestClusterNullableInt64s>(credsIssuerConfig),                                               //
        make_unique<WriteTestClusterNullableEnum8>(credsIssuerConfig),                                                //
        make_unique<WriteTestClusterNullableEnum16>(credsIssuerConfig),                                               //
        make_unique<WriteTestClusterNullableFloatSingle>(credsIssuerConfig),                                          //
        make_unique<WriteTestClusterNullableFloatDouble>(credsIssuerConfig),                                          //
        make_unique<WriteTestClusterNullableOctetString>(credsIssuerConfig),                                          //
        make_unique<WriteTestClusterNullableCharString>(credsIssuerConfig),                                           //
        make_unique<WriteTestClusterNullableEnumAttr>(credsIssuerConfig),                                             //
        make_unique<WriteTestClusterNullableStruct>(credsIssuerConfig),                                               //
        make_unique<WriteTestClusterNullableRangeRestrictedInt8u>(credsIssuerConfig),                                 //
        make_unique<WriteTestClusterNullableRangeRestrictedInt8s>(credsIssuerConfig),                                 //
        make_unique<WriteTestClusterNullableRangeRestrictedInt16u>(credsIssuerConfig),                                //
        make_unique<WriteTestClusterNullableRangeRestrictedInt16s>(credsIssuerConfig),                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                       //
        make_unique<SubscribeAttribute>(Id, "boolean", Attributes::Boolean::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "bitmap8", Attributes::Bitmap8::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "bitmap16", Attributes::Bitmap16::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "bitmap32", Attributes::Bitmap32::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "bitmap64", Attributes::Bitmap64::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "int8u", Attributes::Int8u::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "int16u", Attributes::Int16u::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int24u", Attributes::Int24u::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int32u", Attributes::Int32u::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int40u", Attributes::Int40u::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int48u", Attributes::Int48u::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int56u", Attributes::Int56u::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int64u", Attributes::Int64u::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int8s", Attributes::Int8s::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "int16s", Attributes::Int16s::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int24s", Attributes::Int24s::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int32s", Attributes::Int32s::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int40s", Attributes::Int40s::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int48s", Attributes::Int48s::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int56s", Attributes::Int56s::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "int64s", Attributes::Int64s::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "enum8", Attributes::Enum8::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "enum16", Attributes::Enum16::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "float-single", Attributes::FloatSingle::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "float-double", Attributes::FloatDouble::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "octet-string", Attributes::OctetString::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "list-int8u", Attributes::ListInt8u::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "list-octet-string", Attributes::ListOctetString::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "list-struct-octet-string", Attributes::ListStructOctetString::Id,
                                        credsIssuerConfig),                                                           //
        make_unique<SubscribeAttribute>(Id, "long-octet-string", Attributes::LongOctetString::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "char-string", Attributes::CharString::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "long-char-string", Attributes::LongCharString::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "epoch-us", Attributes::EpochUs::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "epoch-s", Attributes::EpochS::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "vendor-id", Attributes::VendorId::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "list-nullables-and-optionals-struct", Attributes::ListNullablesAndOptionalsStruct::Id,
                                        credsIssuerConfig),                                                                       //
        make_unique<SubscribeAttribute>(Id, "enum-attr", Attributes::EnumAttr::Id, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, "struct-attr", Attributes::StructAttr::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "range-restricted-int8u", Attributes::RangeRestrictedInt8u::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "range-restricted-int8s", Attributes::RangeRestrictedInt8s::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "range-restricted-int16u", Attributes::RangeRestrictedInt16u::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "range-restricted-int16s", Attributes::RangeRestrictedInt16s::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "list-long-octet-string", Attributes::ListLongOctetString::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "timed-write-boolean", Attributes::TimedWriteBoolean::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "general-error-boolean", Attributes::GeneralErrorBoolean::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-error-boolean", Attributes::ClusterErrorBoolean::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "unsupported", Attributes::Unsupported::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "nullable-boolean", Attributes::NullableBoolean::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "nullable-bitmap8", Attributes::NullableBitmap8::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "nullable-bitmap16", Attributes::NullableBitmap16::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "nullable-bitmap32", Attributes::NullableBitmap32::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "nullable-bitmap64", Attributes::NullableBitmap64::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "nullable-int8u", Attributes::NullableInt8u::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "nullable-int16u", Attributes::NullableInt16u::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int24u", Attributes::NullableInt24u::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int32u", Attributes::NullableInt32u::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int40u", Attributes::NullableInt40u::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int48u", Attributes::NullableInt48u::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int56u", Attributes::NullableInt56u::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int64u", Attributes::NullableInt64u::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int8s", Attributes::NullableInt8s::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "nullable-int16s", Attributes::NullableInt16s::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int24s", Attributes::NullableInt24s::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int32s", Attributes::NullableInt32s::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int40s", Attributes::NullableInt40s::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int48s", Attributes::NullableInt48s::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int56s", Attributes::NullableInt56s::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-int64s", Attributes::NullableInt64s::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-enum8", Attributes::NullableEnum8::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "nullable-enum16", Attributes::NullableEnum16::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-float-single", Attributes::NullableFloatSingle::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "nullable-float-double", Attributes::NullableFloatDouble::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "nullable-octet-string", Attributes::NullableOctetString::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "nullable-char-string", Attributes::NullableCharString::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "nullable-enum-attr", Attributes::NullableEnumAttr::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "nullable-struct", Attributes::NullableStruct::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "nullable-range-restricted-int8u", Attributes::NullableRangeRestrictedInt8u::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "nullable-range-restricted-int8s", Attributes::NullableRangeRestrictedInt8s::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "nullable-range-restricted-int16u", Attributes::NullableRangeRestrictedInt16u::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "nullable-range-restricted-int16s", Attributes::NullableRangeRestrictedInt16s::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                                     //
        make_unique<ReadEvent>(Id, "test-event", Events::TestEvent::Id, credsIssuerConfig),                                //
        make_unique<ReadEvent>(Id, "test-fabric-scoped-event", Events::TestFabricScopedEvent::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                                //
        make_unique<SubscribeEvent>(Id, "test-event", Events::TestEvent::Id, credsIssuerConfig),                           //
        make_unique<SubscribeEvent>(Id, "test-fabric-scoped-event", Events::TestFabricScopedEvent::Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterThermostat(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::Thermostat;

    const char * clusterName = "Thermostat";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),            //
        make_unique<ThermostatClearWeeklySchedule>(credsIssuerConfig), //
        make_unique<ThermostatGetRelayStatusLog>(credsIssuerConfig),   //
        make_unique<ThermostatGetWeeklySchedule>(credsIssuerConfig),   //
        make_unique<ThermostatSetWeeklySchedule>(credsIssuerConfig),   //
        make_unique<ThermostatSetpointRaiseLower>(credsIssuerConfig),  //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                        //
        make_unique<ReadAttribute>(Id, "local-temperature", Attributes::LocalTemperature::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "abs-min-heat-setpoint-limit", Attributes::AbsMinHeatSetpointLimit::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "abs-max-heat-setpoint-limit", Attributes::AbsMaxHeatSetpointLimit::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "abs-min-cool-setpoint-limit", Attributes::AbsMinCoolSetpointLimit::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "abs-max-cool-setpoint-limit", Attributes::AbsMaxCoolSetpointLimit::Id,
                                   credsIssuerConfig),                                                                           //
        make_unique<ReadAttribute>(Id, "occupied-cooling-setpoint", Attributes::OccupiedCoolingSetpoint::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "occupied-heating-setpoint", Attributes::OccupiedHeatingSetpoint::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "min-heat-setpoint-limit", Attributes::MinHeatSetpointLimit::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "max-heat-setpoint-limit", Attributes::MaxHeatSetpointLimit::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "min-cool-setpoint-limit", Attributes::MinCoolSetpointLimit::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "max-cool-setpoint-limit", Attributes::MaxCoolSetpointLimit::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "min-setpoint-dead-band", Attributes::MinSetpointDeadBand::Id, credsIssuerConfig),        //
        make_unique<ReadAttribute>(Id, "control-sequence-of-operation", Attributes::ControlSequenceOfOperation::Id,
                                   credsIssuerConfig),                                                   //
        make_unique<ReadAttribute>(Id, "system-mode", Attributes::SystemMode::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "start-of-week", Attributes::StartOfWeek::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "number-of-weekly-transitions", Attributes::NumberOfWeeklyTransitions::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "number-of-daily-transitions", Attributes::NumberOfDailyTransitions::Id,
                                   credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),        //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                            //
        make_unique<WriteThermostatOccupiedCoolingSetpoint>(credsIssuerConfig),                                        //
        make_unique<WriteThermostatOccupiedHeatingSetpoint>(credsIssuerConfig),                                        //
        make_unique<WriteThermostatMinHeatSetpointLimit>(credsIssuerConfig),                                           //
        make_unique<WriteThermostatMaxHeatSetpointLimit>(credsIssuerConfig),                                           //
        make_unique<WriteThermostatMinCoolSetpointLimit>(credsIssuerConfig),                                           //
        make_unique<WriteThermostatMaxCoolSetpointLimit>(credsIssuerConfig),                                           //
        make_unique<WriteThermostatMinSetpointDeadBand>(credsIssuerConfig),                                            //
        make_unique<WriteThermostatControlSequenceOfOperation>(credsIssuerConfig),                                     //
        make_unique<WriteThermostatSystemMode>(credsIssuerConfig),                                                     //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                        //
        make_unique<SubscribeAttribute>(Id, "local-temperature", Attributes::LocalTemperature::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "abs-min-heat-setpoint-limit", Attributes::AbsMinHeatSetpointLimit::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "abs-max-heat-setpoint-limit", Attributes::AbsMaxHeatSetpointLimit::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "abs-min-cool-setpoint-limit", Attributes::AbsMinCoolSetpointLimit::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "abs-max-cool-setpoint-limit", Attributes::AbsMaxCoolSetpointLimit::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "occupied-cooling-setpoint", Attributes::OccupiedCoolingSetpoint::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "occupied-heating-setpoint", Attributes::OccupiedHeatingSetpoint::Id,
                                        credsIssuerConfig),                                                                      //
        make_unique<SubscribeAttribute>(Id, "min-heat-setpoint-limit", Attributes::MinHeatSetpointLimit::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "max-heat-setpoint-limit", Attributes::MaxHeatSetpointLimit::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "min-cool-setpoint-limit", Attributes::MinCoolSetpointLimit::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "max-cool-setpoint-limit", Attributes::MaxCoolSetpointLimit::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "min-setpoint-dead-band", Attributes::MinSetpointDeadBand::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "control-sequence-of-operation", Attributes::ControlSequenceOfOperation::Id,
                                        credsIssuerConfig),                                                   //
        make_unique<SubscribeAttribute>(Id, "system-mode", Attributes::SystemMode::Id, credsIssuerConfig),    //
        make_unique<SubscribeAttribute>(Id, "start-of-week", Attributes::StartOfWeek::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-weekly-transitions", Attributes::NumberOfWeeklyTransitions::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "number-of-daily-transitions", Attributes::NumberOfDailyTransitions::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterThermostatUserInterfaceConfiguration(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ThermostatUserInterfaceConfiguration;

    const char * clusterName = "ThermostatUserInterfaceConfiguration";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "temperature-display-mode", Attributes::TemperatureDisplayMode::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "keypad-lockout", Attributes::KeypadLockout::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "schedule-programming-visibility", Attributes::ScheduleProgrammingVisibility::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<WriteThermostatUserInterfaceConfigurationTemperatureDisplayMode>(credsIssuerConfig),        //
        make_unique<WriteThermostatUserInterfaceConfigurationKeypadLockout>(credsIssuerConfig),                 //
        make_unique<WriteThermostatUserInterfaceConfigurationScheduleProgrammingVisibility>(credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeAttribute>(Id, "temperature-display-mode", Attributes::TemperatureDisplayMode::Id,
                                        credsIssuerConfig),                                                      //
        make_unique<SubscribeAttribute>(Id, "keypad-lockout", Attributes::KeypadLockout::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "schedule-programming-visibility", Attributes::ScheduleProgrammingVisibility::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterThreadNetworkDiagnostics(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::ThreadNetworkDiagnostics;

    const char * clusterName = "ThreadNetworkDiagnostics";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                  //
        make_unique<ThreadNetworkDiagnosticsResetCounts>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                      //
        make_unique<ReadAttribute>(Id, "channel", Attributes::Channel::Id, credsIssuerConfig),                                  //
        make_unique<ReadAttribute>(Id, "routing-role", Attributes::RoutingRole::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "network-name", Attributes::NetworkName::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "pan-id", Attributes::PanId::Id, credsIssuerConfig),                                     //
        make_unique<ReadAttribute>(Id, "extended-pan-id", Attributes::ExtendedPanId::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "mesh-local-prefix", Attributes::MeshLocalPrefix::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "overrun-count", Attributes::OverrunCount::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "neighbor-table-list", Attributes::NeighborTableList::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "route-table-list", Attributes::RouteTableList::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "partition-id", Attributes::PartitionId::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "weighting", Attributes::Weighting::Id, credsIssuerConfig),                              //
        make_unique<ReadAttribute>(Id, "data-version", Attributes::DataVersion::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "stable-data-version", Attributes::StableDataVersion::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "leader-router-id", Attributes::LeaderRouterId::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "detached-role-count", Attributes::DetachedRoleCount::Id, credsIssuerConfig),            //
        make_unique<ReadAttribute>(Id, "child-role-count", Attributes::ChildRoleCount::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "router-role-count", Attributes::RouterRoleCount::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "leader-role-count", Attributes::LeaderRoleCount::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "attach-attempt-count", Attributes::AttachAttemptCount::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "partition-id-change-count", Attributes::PartitionIdChangeCount::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "better-partition-attach-attempt-count", Attributes::BetterPartitionAttachAttemptCount::Id,
                                   credsIssuerConfig),                                                                         //
        make_unique<ReadAttribute>(Id, "parent-change-count", Attributes::ParentChangeCount::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "tx-total-count", Attributes::TxTotalCount::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "tx-unicast-count", Attributes::TxUnicastCount::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "tx-broadcast-count", Attributes::TxBroadcastCount::Id, credsIssuerConfig),             //
        make_unique<ReadAttribute>(Id, "tx-ack-requested-count", Attributes::TxAckRequestedCount::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "tx-acked-count", Attributes::TxAckedCount::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "tx-no-ack-requested-count", Attributes::TxNoAckRequestedCount::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "tx-data-count", Attributes::TxDataCount::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "tx-data-poll-count", Attributes::TxDataPollCount::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "tx-beacon-count", Attributes::TxBeaconCount::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "tx-beacon-request-count", Attributes::TxBeaconRequestCount::Id, credsIssuerConfig),    //
        make_unique<ReadAttribute>(Id, "tx-other-count", Attributes::TxOtherCount::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "tx-retry-count", Attributes::TxRetryCount::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "tx-direct-max-retry-expiry-count", Attributes::TxDirectMaxRetryExpiryCount::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "tx-indirect-max-retry-expiry-count", Attributes::TxIndirectMaxRetryExpiryCount::Id,
                                   credsIssuerConfig),                                                                          //
        make_unique<ReadAttribute>(Id, "tx-err-cca-count", Attributes::TxErrCcaCount::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "tx-err-abort-count", Attributes::TxErrAbortCount::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "tx-err-busy-channel-count", Attributes::TxErrBusyChannelCount::Id, credsIssuerConfig),  //
        make_unique<ReadAttribute>(Id, "rx-total-count", Attributes::RxTotalCount::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "rx-unicast-count", Attributes::RxUnicastCount::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "rx-broadcast-count", Attributes::RxBroadcastCount::Id, credsIssuerConfig),              //
        make_unique<ReadAttribute>(Id, "rx-data-count", Attributes::RxDataCount::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "rx-data-poll-count", Attributes::RxDataPollCount::Id, credsIssuerConfig),               //
        make_unique<ReadAttribute>(Id, "rx-beacon-count", Attributes::RxBeaconCount::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "rx-beacon-request-count", Attributes::RxBeaconRequestCount::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "rx-other-count", Attributes::RxOtherCount::Id, credsIssuerConfig),                      //
        make_unique<ReadAttribute>(Id, "rx-address-filtered-count", Attributes::RxAddressFilteredCount::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "rx-dest-addr-filtered-count", Attributes::RxDestAddrFilteredCount::Id,
                                   credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "rx-duplicated-count", Attributes::RxDuplicatedCount::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "rx-err-no-frame-count", Attributes::RxErrNoFrameCount::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "rx-err-unknown-neighbor-count", Attributes::RxErrUnknownNeighborCount::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "rx-err-invalid-src-addr-count", Attributes::RxErrInvalidSrcAddrCount::Id,
                                   credsIssuerConfig),                                                            //
        make_unique<ReadAttribute>(Id, "rx-err-sec-count", Attributes::RxErrSecCount::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "rx-err-fcs-count", Attributes::RxErrFcsCount::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "rx-err-other-count", Attributes::RxErrOtherCount::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "active-timestamp", Attributes::ActiveTimestamp::Id, credsIssuerConfig),   //
        make_unique<ReadAttribute>(Id, "pending-timestamp", Attributes::PendingTimestamp::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "delay", Attributes::Delay::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "security-policy", Attributes::SecurityPolicy::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "channel-mask", Attributes::ChannelMask::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "operational-dataset-components", Attributes::OperationalDatasetComponents::Id,
                                   credsIssuerConfig),                                                                            //
        make_unique<ReadAttribute>(Id, "active-network-faults-list", Attributes::ActiveNetworkFaultsList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                      //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),             //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                             //
        make_unique<SubscribeAttribute>(Id, "channel", Attributes::Channel::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "routing-role", Attributes::RoutingRole::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "network-name", Attributes::NetworkName::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "pan-id", Attributes::PanId::Id, credsIssuerConfig),                            //
        make_unique<SubscribeAttribute>(Id, "extended-pan-id", Attributes::ExtendedPanId::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "mesh-local-prefix", Attributes::MeshLocalPrefix::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "overrun-count", Attributes::OverrunCount::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "neighbor-table-list", Attributes::NeighborTableList::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "route-table-list", Attributes::RouteTableList::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "partition-id", Attributes::PartitionId::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "weighting", Attributes::Weighting::Id, credsIssuerConfig),                     //
        make_unique<SubscribeAttribute>(Id, "data-version", Attributes::DataVersion::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "stable-data-version", Attributes::StableDataVersion::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "leader-router-id", Attributes::LeaderRouterId::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "detached-role-count", Attributes::DetachedRoleCount::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "child-role-count", Attributes::ChildRoleCount::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "router-role-count", Attributes::RouterRoleCount::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "leader-role-count", Attributes::LeaderRoleCount::Id, credsIssuerConfig),       //
        make_unique<SubscribeAttribute>(Id, "attach-attempt-count", Attributes::AttachAttemptCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "partition-id-change-count", Attributes::PartitionIdChangeCount::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "better-partition-attach-attempt-count",
                                        Attributes::BetterPartitionAttachAttemptCount::Id, credsIssuerConfig),                 //
        make_unique<SubscribeAttribute>(Id, "parent-change-count", Attributes::ParentChangeCount::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "tx-total-count", Attributes::TxTotalCount::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "tx-unicast-count", Attributes::TxUnicastCount::Id, credsIssuerConfig),            //
        make_unique<SubscribeAttribute>(Id, "tx-broadcast-count", Attributes::TxBroadcastCount::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "tx-ack-requested-count", Attributes::TxAckRequestedCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "tx-acked-count", Attributes::TxAckedCount::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "tx-no-ack-requested-count", Attributes::TxNoAckRequestedCount::Id,
                                        credsIssuerConfig),                                                                      //
        make_unique<SubscribeAttribute>(Id, "tx-data-count", Attributes::TxDataCount::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "tx-data-poll-count", Attributes::TxDataPollCount::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "tx-beacon-count", Attributes::TxBeaconCount::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "tx-beacon-request-count", Attributes::TxBeaconRequestCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "tx-other-count", Attributes::TxOtherCount::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "tx-retry-count", Attributes::TxRetryCount::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "tx-direct-max-retry-expiry-count", Attributes::TxDirectMaxRetryExpiryCount::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "tx-indirect-max-retry-expiry-count", Attributes::TxIndirectMaxRetryExpiryCount::Id,
                                        credsIssuerConfig),                                                            //
        make_unique<SubscribeAttribute>(Id, "tx-err-cca-count", Attributes::TxErrCcaCount::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "tx-err-abort-count", Attributes::TxErrAbortCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "tx-err-busy-channel-count", Attributes::TxErrBusyChannelCount::Id,
                                        credsIssuerConfig),                                                                      //
        make_unique<SubscribeAttribute>(Id, "rx-total-count", Attributes::RxTotalCount::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "rx-unicast-count", Attributes::RxUnicastCount::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "rx-broadcast-count", Attributes::RxBroadcastCount::Id, credsIssuerConfig),          //
        make_unique<SubscribeAttribute>(Id, "rx-data-count", Attributes::RxDataCount::Id, credsIssuerConfig),                    //
        make_unique<SubscribeAttribute>(Id, "rx-data-poll-count", Attributes::RxDataPollCount::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "rx-beacon-count", Attributes::RxBeaconCount::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "rx-beacon-request-count", Attributes::RxBeaconRequestCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rx-other-count", Attributes::RxOtherCount::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "rx-address-filtered-count", Attributes::RxAddressFilteredCount::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rx-dest-addr-filtered-count", Attributes::RxDestAddrFilteredCount::Id,
                                        credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "rx-duplicated-count", Attributes::RxDuplicatedCount::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "rx-err-no-frame-count", Attributes::RxErrNoFrameCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rx-err-unknown-neighbor-count", Attributes::RxErrUnknownNeighborCount::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "rx-err-invalid-src-addr-count", Attributes::RxErrInvalidSrcAddrCount::Id,
                                        credsIssuerConfig),                                                            //
        make_unique<SubscribeAttribute>(Id, "rx-err-sec-count", Attributes::RxErrSecCount::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "rx-err-fcs-count", Attributes::RxErrFcsCount::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "rx-err-other-count", Attributes::RxErrOtherCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "active-timestamp", Attributes::ActiveTimestamp::Id, credsIssuerConfig),   //
        make_unique<SubscribeAttribute>(Id, "pending-timestamp", Attributes::PendingTimestamp::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "delay", Attributes::Delay::Id, credsIssuerConfig),                        //
        make_unique<SubscribeAttribute>(Id, "security-policy", Attributes::SecurityPolicy::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "channel-mask", Attributes::ChannelMask::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "operational-dataset-components", Attributes::OperationalDatasetComponents::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "active-network-faults-list", Attributes::ActiveNetworkFaultsList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                         //
        make_unique<ReadEvent>(Id, "connection-status", Events::ConnectionStatus::Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                    //
        make_unique<SubscribeEvent>(Id, "connection-status", Events::ConnectionStatus::Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterTimeFormatLocalization(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::TimeFormatLocalization;

    const char * clusterName = "TimeFormatLocalization";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                     //
        make_unique<ReadAttribute>(Id, "hour-format", Attributes::HourFormat::Id, credsIssuerConfig),                          //
        make_unique<ReadAttribute>(Id, "active-calendar-type", Attributes::ActiveCalendarType::Id, credsIssuerConfig),         //
        make_unique<ReadAttribute>(Id, "supported-calendar-types", Attributes::SupportedCalendarTypes::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                      //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),             //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<WriteTimeFormatLocalizationHourFormat>(credsIssuerConfig),                                              //
        make_unique<WriteTimeFormatLocalizationActiveCalendarType>(credsIssuerConfig),                                      //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                             //
        make_unique<SubscribeAttribute>(Id, "hour-format", Attributes::HourFormat::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "active-calendar-type", Attributes::ActiveCalendarType::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "supported-calendar-types", Attributes::SupportedCalendarTypes::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterUnitLocalization(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::UnitLocalization;

    const char * clusterName = "UnitLocalization";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                           //
        make_unique<ReadAttribute>(Id, "temperature-unit", Attributes::TemperatureUnit::Id, credsIssuerConfig),      //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),          //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),      //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                          //
        make_unique<WriteUnitLocalizationTemperatureUnit>(credsIssuerConfig),                                        //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                      //
        make_unique<SubscribeAttribute>(Id, "temperature-unit", Attributes::TemperatureUnit::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterUserLabel(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::UserLabel;

    const char * clusterName = "UserLabel";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                          //
        make_unique<ReadAttribute>(Id, "label-list", Attributes::LabelList::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                          //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                     //
        make_unique<WriteUserLabelLabelList>(credsIssuerConfig),                                                //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                 //
        make_unique<SubscribeAttribute>(Id, "label-list", Attributes::LabelList::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterWakeOnLan(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::WakeOnLan;

    const char * clusterName = "WakeOnLan";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<ReadAttribute>(Id, "wake-on-lan-mac-address", Attributes::WakeOnLanMacAddress::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                          //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),                 //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                                     //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                                 //
        make_unique<SubscribeAttribute>(Id, "wake-on-lan-mac-address", Attributes::WakeOnLanMacAddress::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterWiFiNetworkDiagnostics(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::WiFiNetworkDiagnostics;

    const char * clusterName = "WiFiNetworkDiagnostics";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),                //
        make_unique<WiFiNetworkDiagnosticsResetCounts>(credsIssuerConfig), //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                                      //
        make_unique<ReadAttribute>(Id, "bssid", Attributes::Bssid::Id, credsIssuerConfig),                                      //
        make_unique<ReadAttribute>(Id, "security-type", Attributes::SecurityType::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "wi-fi-version", Attributes::WiFiVersion::Id, credsIssuerConfig),                        //
        make_unique<ReadAttribute>(Id, "channel-number", Attributes::ChannelNumber::Id, credsIssuerConfig),                     //
        make_unique<ReadAttribute>(Id, "rssi", Attributes::Rssi::Id, credsIssuerConfig),                                        //
        make_unique<ReadAttribute>(Id, "beacon-lost-count", Attributes::BeaconLostCount::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "beacon-rx-count", Attributes::BeaconRxCount::Id, credsIssuerConfig),                    //
        make_unique<ReadAttribute>(Id, "packet-multicast-rx-count", Attributes::PacketMulticastRxCount::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "packet-multicast-tx-count", Attributes::PacketMulticastTxCount::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "packet-unicast-rx-count", Attributes::PacketUnicastRxCount::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "packet-unicast-tx-count", Attributes::PacketUnicastTxCount::Id, credsIssuerConfig),     //
        make_unique<ReadAttribute>(Id, "current-max-rate", Attributes::CurrentMaxRate::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "overrun-count", Attributes::OverrunCount::Id, credsIssuerConfig),                       //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),           //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                 //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),       //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                           //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                       //
        make_unique<SubscribeAttribute>(Id, "bssid", Attributes::Bssid::Id, credsIssuerConfig),                       //
        make_unique<SubscribeAttribute>(Id, "security-type", Attributes::SecurityType::Id, credsIssuerConfig),        //
        make_unique<SubscribeAttribute>(Id, "wi-fi-version", Attributes::WiFiVersion::Id, credsIssuerConfig),         //
        make_unique<SubscribeAttribute>(Id, "channel-number", Attributes::ChannelNumber::Id, credsIssuerConfig),      //
        make_unique<SubscribeAttribute>(Id, "rssi", Attributes::Rssi::Id, credsIssuerConfig),                         //
        make_unique<SubscribeAttribute>(Id, "beacon-lost-count", Attributes::BeaconLostCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "beacon-rx-count", Attributes::BeaconRxCount::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "packet-multicast-rx-count", Attributes::PacketMulticastRxCount::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "packet-multicast-tx-count", Attributes::PacketMulticastTxCount::Id,
                                        credsIssuerConfig),                                                                      //
        make_unique<SubscribeAttribute>(Id, "packet-unicast-rx-count", Attributes::PacketUnicastRxCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "packet-unicast-tx-count", Attributes::PacketUnicastTxCount::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "current-max-rate", Attributes::CurrentMaxRate::Id, credsIssuerConfig),              //
        make_unique<SubscribeAttribute>(Id, "overrun-count", Attributes::OverrunCount::Id, credsIssuerConfig),                   //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),                                                             //
        make_unique<ReadEvent>(Id, "disconnection", Events::Disconnection::Id, credsIssuerConfig),                 //
        make_unique<ReadEvent>(Id, "association-failure", Events::AssociationFailure::Id, credsIssuerConfig),      //
        make_unique<ReadEvent>(Id, "connection-status", Events::ConnectionStatus::Id, credsIssuerConfig),          //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig),                                                        //
        make_unique<SubscribeEvent>(Id, "disconnection", Events::Disconnection::Id, credsIssuerConfig),            //
        make_unique<SubscribeEvent>(Id, "association-failure", Events::AssociationFailure::Id, credsIssuerConfig), //
        make_unique<SubscribeEvent>(Id, "connection-status", Events::ConnectionStatus::Id, credsIssuerConfig),     //
    };

    commands.Register(clusterName, clusterCommands);
}
void registerClusterWindowCovering(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    using namespace chip::app::Clusters::WindowCovering;

    const char * clusterName = "WindowCovering";

    commands_list clusterCommands = {
        //
        // Commands
        //
        make_unique<ClusterCommand>(Id, credsIssuerConfig),               //
        make_unique<WindowCoveringDownOrClose>(credsIssuerConfig),        //
        make_unique<WindowCoveringGoToLiftPercentage>(credsIssuerConfig), //
        make_unique<WindowCoveringGoToLiftValue>(credsIssuerConfig),      //
        make_unique<WindowCoveringGoToTiltPercentage>(credsIssuerConfig), //
        make_unique<WindowCoveringGoToTiltValue>(credsIssuerConfig),      //
        make_unique<WindowCoveringStopMotion>(credsIssuerConfig),         //
        make_unique<WindowCoveringUpOrOpen>(credsIssuerConfig),           //
        //
        // Attributes
        //
        make_unique<ReadAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<ReadAttribute>(Id, "type", Attributes::Type::Id, credsIssuerConfig),                                 //
        make_unique<ReadAttribute>(Id, "current-position-lift", Attributes::CurrentPositionLift::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "current-position-tilt", Attributes::CurrentPositionTilt::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "config-status", Attributes::ConfigStatus::Id, credsIssuerConfig),                //
        make_unique<ReadAttribute>(Id, "current-position-lift-percentage", Attributes::CurrentPositionLiftPercentage::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "current-position-tilt-percentage", Attributes::CurrentPositionTiltPercentage::Id,
                                   credsIssuerConfig),                                                              //
        make_unique<ReadAttribute>(Id, "operational-status", Attributes::OperationalStatus::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "target-position-lift-percent100ths", Attributes::TargetPositionLiftPercent100ths::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "target-position-tilt-percent100ths", Attributes::TargetPositionTiltPercent100ths::Id,
                                   credsIssuerConfig),                                                         //
        make_unique<ReadAttribute>(Id, "end-product-type", Attributes::EndProductType::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "current-position-lift-percent100ths", Attributes::CurrentPositionLiftPercent100ths::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "current-position-tilt-percent100ths", Attributes::CurrentPositionTiltPercent100ths::Id,
                                   credsIssuerConfig),                                                                          //
        make_unique<ReadAttribute>(Id, "installed-open-limit-lift", Attributes::InstalledOpenLimitLift::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "installed-closed-limit-lift", Attributes::InstalledClosedLimitLift::Id,
                                   credsIssuerConfig),                                                                          //
        make_unique<ReadAttribute>(Id, "installed-open-limit-tilt", Attributes::InstalledOpenLimitTilt::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "installed-closed-limit-tilt", Attributes::InstalledClosedLimitTilt::Id,
                                   credsIssuerConfig),                                                    //
        make_unique<ReadAttribute>(Id, "mode", Attributes::Mode::Id, credsIssuerConfig),                  //
        make_unique<ReadAttribute>(Id, "safety-status", Attributes::SafetyStatus::Id, credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                   credsIssuerConfig), //
        make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                   credsIssuerConfig),                                                                        //
        make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),                   //
        make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),                         //
        make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig),               //
        make_unique<WriteAttribute>(Id, credsIssuerConfig),                                                                   //
        make_unique<WriteWindowCoveringMode>(credsIssuerConfig),                                                              //
        make_unique<SubscribeAttribute>(Id, credsIssuerConfig),                                                               //
        make_unique<SubscribeAttribute>(Id, "type", Attributes::Type::Id, credsIssuerConfig),                                 //
        make_unique<SubscribeAttribute>(Id, "current-position-lift", Attributes::CurrentPositionLift::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "current-position-tilt", Attributes::CurrentPositionTilt::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "config-status", Attributes::ConfigStatus::Id, credsIssuerConfig),                //
        make_unique<SubscribeAttribute>(Id, "current-position-lift-percentage", Attributes::CurrentPositionLiftPercentage::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "current-position-tilt-percentage", Attributes::CurrentPositionTiltPercentage::Id,
                                        credsIssuerConfig),                                                              //
        make_unique<SubscribeAttribute>(Id, "operational-status", Attributes::OperationalStatus::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "target-position-lift-percent100ths", Attributes::TargetPositionLiftPercent100ths::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "target-position-tilt-percent100ths", Attributes::TargetPositionTiltPercent100ths::Id,
                                        credsIssuerConfig),                                                         //
        make_unique<SubscribeAttribute>(Id, "end-product-type", Attributes::EndProductType::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "current-position-lift-percent100ths", Attributes::CurrentPositionLiftPercent100ths::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "current-position-tilt-percent100ths", Attributes::CurrentPositionTiltPercent100ths::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "installed-open-limit-lift", Attributes::InstalledOpenLimitLift::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "installed-closed-limit-lift", Attributes::InstalledClosedLimitLift::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "installed-open-limit-tilt", Attributes::InstalledOpenLimitTilt::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "installed-closed-limit-tilt", Attributes::InstalledClosedLimitTilt::Id,
                                        credsIssuerConfig),                                                    //
        make_unique<SubscribeAttribute>(Id, "mode", Attributes::Mode::Id, credsIssuerConfig),                  //
        make_unique<SubscribeAttribute>(Id, "safety-status", Attributes::SafetyStatus::Id, credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
                                        credsIssuerConfig), //
        make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
                                        credsIssuerConfig),                                                          //
        make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig),           //
        make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
        //
        // Events
        //
        make_unique<ReadEvent>(Id, credsIssuerConfig),      //
        make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
    };

    commands.Register(clusterName, clusterCommands);
}

void registerClusterAny(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    const char * clusterName = "Any";

    commands_list clusterCommands = {
        make_unique<ClusterCommand>(credsIssuerConfig),     //
        make_unique<ReadAttribute>(credsIssuerConfig),      //
        make_unique<WriteAttribute>(credsIssuerConfig),     //
        make_unique<SubscribeAttribute>(credsIssuerConfig), //
        make_unique<ReadEvent>(credsIssuerConfig),          //
        make_unique<SubscribeEvent>(credsIssuerConfig),     //
    };

    commands.Register(clusterName, clusterCommands);
}

void registerClusters(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
    registerClusterAny(commands, credsIssuerConfig);
    registerClusterAccessControl(commands, credsIssuerConfig);
    registerClusterAccountLogin(commands, credsIssuerConfig);
    registerClusterAdministratorCommissioning(commands, credsIssuerConfig);
    registerClusterApplicationBasic(commands, credsIssuerConfig);
    registerClusterApplicationLauncher(commands, credsIssuerConfig);
    registerClusterAudioOutput(commands, credsIssuerConfig);
    registerClusterBarrierControl(commands, credsIssuerConfig);
    registerClusterBasic(commands, credsIssuerConfig);
    registerClusterBinaryInputBasic(commands, credsIssuerConfig);
    registerClusterBinding(commands, credsIssuerConfig);
    registerClusterBooleanState(commands, credsIssuerConfig);
    registerClusterBridgedActions(commands, credsIssuerConfig);
    registerClusterBridgedDeviceBasic(commands, credsIssuerConfig);
    registerClusterChannel(commands, credsIssuerConfig);
    registerClusterColorControl(commands, credsIssuerConfig);
    registerClusterContentLauncher(commands, credsIssuerConfig);
    registerClusterDescriptor(commands, credsIssuerConfig);
    registerClusterDiagnosticLogs(commands, credsIssuerConfig);
    registerClusterDoorLock(commands, credsIssuerConfig);
    registerClusterElectricalMeasurement(commands, credsIssuerConfig);
    registerClusterEthernetNetworkDiagnostics(commands, credsIssuerConfig);
    registerClusterFixedLabel(commands, credsIssuerConfig);
    registerClusterFlowMeasurement(commands, credsIssuerConfig);
    registerClusterGeneralCommissioning(commands, credsIssuerConfig);
    registerClusterGeneralDiagnostics(commands, credsIssuerConfig);
    registerClusterGroupKeyManagement(commands, credsIssuerConfig);
    registerClusterGroups(commands, credsIssuerConfig);
    registerClusterIdentify(commands, credsIssuerConfig);
    registerClusterIlluminanceMeasurement(commands, credsIssuerConfig);
    registerClusterKeypadInput(commands, credsIssuerConfig);
    registerClusterLevelControl(commands, credsIssuerConfig);
    registerClusterLocalizationConfiguration(commands, credsIssuerConfig);
    registerClusterLowPower(commands, credsIssuerConfig);
    registerClusterMediaInput(commands, credsIssuerConfig);
    registerClusterMediaPlayback(commands, credsIssuerConfig);
    registerClusterModeSelect(commands, credsIssuerConfig);
    registerClusterNetworkCommissioning(commands, credsIssuerConfig);
    registerClusterOtaSoftwareUpdateProvider(commands, credsIssuerConfig);
    registerClusterOtaSoftwareUpdateRequestor(commands, credsIssuerConfig);
    registerClusterOccupancySensing(commands, credsIssuerConfig);
    registerClusterOnOff(commands, credsIssuerConfig);
    registerClusterOnOffSwitchConfiguration(commands, credsIssuerConfig);
    registerClusterOperationalCredentials(commands, credsIssuerConfig);
    registerClusterPowerSource(commands, credsIssuerConfig);
    registerClusterPowerSourceConfiguration(commands, credsIssuerConfig);
    registerClusterPressureMeasurement(commands, credsIssuerConfig);
    registerClusterPumpConfigurationAndControl(commands, credsIssuerConfig);
    registerClusterRelativeHumidityMeasurement(commands, credsIssuerConfig);
    registerClusterScenes(commands, credsIssuerConfig);
    registerClusterSoftwareDiagnostics(commands, credsIssuerConfig);
    registerClusterSwitch(commands, credsIssuerConfig);
    registerClusterTargetNavigator(commands, credsIssuerConfig);
    registerClusterTemperatureMeasurement(commands, credsIssuerConfig);
    registerClusterTestCluster(commands, credsIssuerConfig);
    registerClusterThermostat(commands, credsIssuerConfig);
    registerClusterThermostatUserInterfaceConfiguration(commands, credsIssuerConfig);
    registerClusterThreadNetworkDiagnostics(commands, credsIssuerConfig);
    registerClusterTimeFormatLocalization(commands, credsIssuerConfig);
    registerClusterUnitLocalization(commands, credsIssuerConfig);
    registerClusterUserLabel(commands, credsIssuerConfig);
    registerClusterWakeOnLan(commands, credsIssuerConfig);
    registerClusterWiFiNetworkDiagnostics(commands, credsIssuerConfig);
    registerClusterWindowCovering(commands, credsIssuerConfig);
}
